public void Execute()
{
var mask = new NodeMask();
mask.Label = "Nodes reachable by multiple cluster";
mask.IsShowMask = false;
var transformationModule = myPresentation.GetModule <ITransformationModule>();
// nodeId -> clusterId
var cache = new Dictionary <Node, string>();
// add starts
var clusterNodes = new HashSet <string>();
foreach (var cluster in transformationModule.Graph.Clusters)
{
foreach (var clusterNode in cluster.Nodes)
{
cache[clusterNode] = cluster.Id;
clusterNodes.Add(clusterNode.Id);
}
}
foreach (var edge in Traverse.BreathFirst(cache.Keys, source => source.Out.Where(e => myPresentation.Picking.Pick(e.Target))))
{
// do not hide cluster nodes
if (clusterNodes.Contains(edge.Target.Id))
{
continue;
}
var sourceClusterId = cache[edge.Source];
if (sourceClusterId == null)
{
// on multiple path
mask.Set(edge.Target);
cache[edge.Target] = null;
continue;
}
string existingClusterId;
if (cache.TryGetValue(edge.Target, out existingClusterId) && existingClusterId != sourceClusterId)
{
// multiple path detected
mask.Set(edge.Target);
cache[edge.Target] = null;
}
else
{
// first path found
cache[edge.Target] = sourceClusterId;
}
}
var module = myPresentation.GetModule <INodeMaskModule>();
module.Push(mask);
}
protected override void OnModelPropertyChanged(string propertyName)
{
if (propertyName == "Model")
{
OnConfigChanged(this, EventArgs.Empty);
}
else if (propertyName == "Presentation")
{
if (myPresentation == Model.Presentation)
{
return;
}
myPresentation = Model.Presentation;
myPresentation.GetModule <INodeMaskModule>().AutoHideAllNodesForShowMasks = true;
if (myPresentation.Graph.Nodes.Count() > DotToolLayoutEngine.FastRenderingNodeCountLimit)
{
new ChangeClusterFolding(myPresentation)
.FoldUnfoldAllClusters();
}
var graphLayoutModule = myPresentation.GetModule <IGraphLayoutModule>();
graphLayoutModule.Algorithm = LayoutAlgorithm;
PropertyBinding.Bind(() => LayoutAlgorithm, () => graphLayoutModule.Algorithm);
RaisePropertyChanged(nameof(IsEnabled));
}
}
public void Execute(IReadOnlyCollection <Node> nodes)
{
var connectedNodes = nodes
.SelectMany(n => GetReachableNodes(n))
.Distinct();
var mask = new NodeMask();
mask.IsShowMask = Show;
if (Show)
{
mask.Set(connectedNodes);
}
else
{
var transformationModule = myPresentation.GetModule <ITransformationModule>();
mask.Set(transformationModule.Graph.Nodes.Except(connectedNodes));
}
if (nodes.Count == 1)
{
var caption = myPresentation.GetPropertySetFor <Caption>().Get(nodes.First().Id);
mask.Label = (Reverse ? "Reverse t" : "T") + "ransitive hull of " + caption.DisplayText;
}
else
{
mask.Label = (Reverse ? "Reverse t" : "T") + "ransitive hull of multiple nodes";
}
var module = myPresentation.GetModule <INodeMaskModule>();
module.Push(mask);
}
public void Execute(IEnumerable <Node> nodes)
{
var mask = new NodeMask();
mask.IsShowMask = myShow;
if (myNegate)
{
var transformationModule = myPresentation.GetModule <ITransformationModule>();
mask.Set(transformationModule.Graph.Nodes.Except(nodes));
}
else
{
mask.Set(nodes);
}
if (nodes.Count() == 1)
{
var caption = myPresentation.GetPropertySetFor <Caption>().Get(nodes.First().Id);
mask.Label = (myNegate ? "Not " : "") + caption.DisplayText;
}
else
{
var caption = myPresentation.GetPropertySetFor <Caption>().Get(nodes.First().Id);
mask.Label = caption.DisplayText + "...";
}
if (myNegate)
{
mask.Label = "Not " + mask.Label;
}
var module = myPresentation.GetModule <INodeMaskModule>();
module.Push(mask);
}
public void Relayout(IGraphPresentation presentation)
{
var layoutAlgorithm = presentation.GetModule <IGraphLayoutModule>().Algorithm;
var writer = new DotWriter(myDotFile.FullName);
writer.FastRenderingNodeCountLimit = FastRenderingNodeCountLimit;
writer.IgnoreStyle = true;
if (layoutAlgorithm == LayoutAlgorithm.Flow)
{
writer.Settings = DotPresets.Flow;
}
var writtenNodesCount = writer.Write(presentation.GetModule <ITransformationModule>().Graph, presentation.Picking, presentation);
myConverter.Algorithm = layoutAlgorithm == LayoutAlgorithm.Auto && writtenNodesCount > FastRenderingNodeCountLimit
? LayoutAlgorithm.Sfdp
: presentation.GetModule <IGraphLayoutModule>().Algorithm;
myConverter.Convert(myDotFile, myPlainFile);
// if converter changed algo (e.g. because of issues) we want to re-apply it to the presentation
presentation.GetModule <IGraphLayoutModule>().Algorithm = myConverter.Algorithm;
var nodeLayouts = new List <NodeLayout>();
var edgeLayouts = new List <EdgeLayout>();
ParsePlainFile(nodeLayouts, edgeLayouts, presentation.GetPropertySetFor <Caption>());
var module = presentation.GetModule <IGraphLayoutModule>();
module.Set(nodeLayouts, edgeLayouts);
}
public void Execute(Cluster cluster, NodeType nodeType)
{
var transformations = myPresentation.GetModule <ITransformationModule>();
var transformation = transformations.Items
.OfType <ClusterFoldingTransformation>()
.SingleOrDefault();
if (transformation == null)
{
return;
}
if (!transformation.Clusters.Contains(cluster.Id))
{
return;
}
var clusterNodeId = transformation.GetClusterNodeId(cluster.Id);
var clusterNode = transformations.Graph.Nodes.Single(n => n.Id == clusterNodeId);
var referencingNodes = new HashSet <string>(GetVisibleSiblings(clusterNode));
// unfold
transformation.Toggle(cluster.Id);
var unfoldedCluster = transformations.Graph.Clusters.Single(c => c.Id == cluster.Id);
// so fare the unfoldedCluster nodes are NOT visible ... if we have used s.th. like "show siblings"
// on the cluster node!
var referencedNodes = unfoldedCluster.Nodes
.Where(n =>
{
var nodes = Enumerable.Empty <string>();
if (nodeType == NodeType.AllSiblings || nodeType == NodeType.Sources)
{
nodes = nodes.Concat(n.Out.Select(e => e.Target.Id));
}
if (nodeType == NodeType.AllSiblings || nodeType == NodeType.Targets)
{
nodes = nodes.Concat(n.In.Select(e => e.Source.Id));
}
return(nodes.Any(referencingNodes.Contains));
});
var mask = new NodeMask();
mask.Set(referencedNodes);
var caption = myPresentation.GetPropertySetFor <Caption>().Get(cluster.Id);
var maskType = nodeType == NodeType.AllSiblings ? "Siblings" : (nodeType == NodeType.Sources ? "Sources" : "Targets");
mask.Label = maskType + " of " + caption.DisplayText;
var module = myPresentation.GetModule <INodeMaskModule>();
module.Push(mask);
}
public void Execute(Node from, Node to)
{
var captions = myPresentation.GetModule <ICaptionModule>();
var mask = new NodeMask();
mask.Label = string.Format("Path from {0} to {1}", captions.Get(from.Id).DisplayText, captions.Get(to.Id).DisplayText);
mask.IsShowMask = true;
mask.Set(GetPaths(from, to));
var module = myPresentation.GetModule <INodeMaskModule>();
module.Push(mask);
}
protected override void OnModelPropertyChanged(string propertyName)
{
if (propertyName == "Model")
{
OnConfigChanged(this, EventArgs.Empty);
}
else if (propertyName == "Presentation")
{
if (myPresentation == Model.Presentation)
{
return;
}
myPresentation = Model.Presentation;
if (myPresentation.Graph.Nodes.Count() > DotToolLayoutEngine.FastRenderingNodeCountLimit)
{
myPresentation.ToogleFoldingOfVisibleClusters();
}
var graphLayoutModule = myPresentation.GetModule <IGraphLayoutModule>();
graphLayoutModule.Algorithm = LayoutAlgorithm;
PropertyBinding.Bind(() => LayoutAlgorithm, () => graphLayoutModule.Algorithm);
RaisePropertyChanged(nameof(IsEnabled));
}
}
public void Execute(Node node)
{
var nodesToShow = GetNodeWithSiblings(node);
var mask = new NodeMask();
mask.Set(nodesToShow);
var caption = myPresentation.GetPropertySetFor <Caption>().Get(node.Id);
mask.Label = "Siblings of " + caption.DisplayText;
var module = myPresentation.GetModule <INodeMaskModule>();
module.Push(mask);
}
private Rect GetBoundingBox(IDictionary <string, AbstractElementVisual> drawingElements)
{
// 1. include all visible nodes within this cluster
var visibleNodes = Owner.Nodes
.Where(n => myPresentation.Picking.Pick(n))
.ToList();
var box = drawingElements[visibleNodes.First().Id].Visual.ContentBounds;
foreach (var node in visibleNodes.Skip(1))
{
var nodeBox = drawingElements[node.Id].Visual.ContentBounds;
box.Union(nodeBox);
}
// 2. include all visible edges which have source and target within this cluster
var transformationModule = myPresentation.GetModule <ITransformationModule>();
var visibleEdges = transformationModule.Graph.Edges
.Where(e => visibleNodes.Contains(e.Source) && visibleNodes.Contains(e.Target))
.Where(e => myPresentation.Picking.Pick(e))
.ToList();
foreach (var edge in visibleEdges)
{
var nodeBox = drawingElements[edge.Id].Visual.ContentBounds;
box.Union(nodeBox);
}
return(box);
}
public void Execute()
{
var transformationModule = myPresentation.GetModule <ITransformationModule>();
var nodesToHide = transformationModule.Graph.Nodes
.Where(node => !(transformationModule.Graph.Clusters.Any(c => c.Nodes.Any(n => n.Id == node.Id))));
var mask = new NodeMask();
mask.IsShowMask = true;
mask.Set(nodesToHide);
mask.Label = "Nodes outside clusters";
var module = myPresentation.GetModule <INodeMaskModule>();
module.Push(mask);
}
public void Draw(EdgeLayout layoutState)
{
var styleState = myPresentation.GetPropertySetFor <EdgeStyle>().Get(Owner.Id);
var label = myPresentation.GetPropertySetFor <Caption>().Get(Owner.Id);
var stream = new StreamGeometry();
var context = stream.Open();
context.BeginFigure(layoutState.Points.First(), false, false);
context.PolyBezierTo(layoutState.Points.Skip(1).ToList(), true, false);
// draw arrow head
{
var start = layoutState.Points.Last();
var v = start - layoutState.Points.ElementAt(layoutState.Points.Count() - 2);
v.Normalize();
start = start - v * 0.05;
context.BeginFigure(start + v * 0.18, true, true);
// Rotate 90°
double t = v.X;
v.X = v.Y;
v.Y = -t;
context.LineTo(start + v * 0.06, true, true);
context.LineTo(start + v * -0.06, true, true);
context.Close();
}
var pen = new Pen(styleState.Color, 1);
SetLineThickness(pen);
// http://stackoverflow.com/questions/1755520/improve-drawingvisual-renders-speed
Visual = new DrawingVisual();
var dc = Visual.RenderOpen();
dc.DrawGeometry(pen.Brush, pen, stream);
if (label.DisplayText != label.OwnerId)
{
var sourceLayoutState = myPresentation.GetModule <IGraphLayoutModule>().GetLayout(Owner.Source);
var tx = new FormattedText(label.DisplayText,
CultureInfo.InvariantCulture,
FlowDirection.LeftToRight,
myFont,
sourceLayoutState.Height * 0.5, Brushes.Black);
dc.DrawText(tx, new Point(layoutState.LabelPosition.X - tx.Width, layoutState.LabelPosition.Y - tx.Height));
}
dc.Close();
Visual.SetValue(GraphItemProperty, Owner);
}
private void SyncToDocument(IGraphPresentation p, string path)
{
myFileWatcher.EnableRaisingEvents = false;
using (new Profile("GraphToDotSynchronizer:OnTransformationsChanged"))
{
var graph = new Graph();
foreach (var n in p.Graph.Nodes)
{
graph.TryAdd(n);
}
foreach (var e in p.Graph.Edges)
{
graph.TryAdd(e);
}
var transformationModule = p.GetModule <ITransformationModule>();
foreach (var cluster in transformationModule.Graph.Clusters.OrderBy(c => c.Id))
{
// we do not want to see the pseudo node added for folding but the full expanded list of nodes of this cluster
var folding = transformationModule.Items
.OfType <ClusterFoldingTransformation>()
.SingleOrDefault(f => f.Clusters.Contains(cluster.Id));
// the nodes we get through ITransformationModule might be new instances!
// -> get the right node instances based on the returned ids
// (otherwiese the writer below will remove them from the output)
var nodes = (folding == null ? cluster.Nodes : folding.GetNodes(cluster.Id))
.Select(n => graph.GetNode(n.Id))
.ToList();
graph.TryAdd(new Cluster(cluster.Id, nodes));
}
var writer = new DotWriter(path);
writer.PrettyPrint = true;
if (p.GetModule <IGraphLayoutModule>().Algorithm == LayoutAlgorithm.Flow)
{
writer.Settings = DotPresets.Flow;
}
writer.Write(graph, new NullGraphPicking(), p);
}
myFileWatcher.EnableRaisingEvents = true;
}
public void Execute()
{
var transformationModule = myPresentation.GetModule <ITransformationModule>();
var nodesToHide = transformationModule.Graph.Nodes
.Where(n => !HasEdges(n));
var mask = new NodeMask();
mask.IsShowMask = false;
mask.Set(nodesToHide);
mask.Label = "Nodes without Edges";
var module = myPresentation.GetModule <INodeMaskModule>();
module.Push(mask);
}
public void Execute(Action <DynamicClusterTransformation> action)
{
var transformations = myPresentation.GetModule <ITransformationModule>();
var transformation = transformations.Items
.OfType <DynamicClusterTransformation>()
.Single();
action(transformation);
}
private void Process(IDocument document)
{
var graphDoc = document as IGraphDocument;
if (graphDoc != null)
{
myPresentation.Graph = graphDoc.Graph;
myFailedItems.AddRange(graphDoc.FailedItems);
}
var styleDoc = document as IStyleDocument;
if (styleDoc != null)
{
var nodeStyles = myPresentation.GetPropertySetFor <NodeStyle>();
foreach (var style in styleDoc.NodeStyles)
{
nodeStyles.Add(style);
}
var edgeStyles = myPresentation.GetPropertySetFor <EdgeStyle>();
foreach (var style in styleDoc.EdgeStyles)
{
edgeStyles.Add(style);
}
}
var layoutDoc = document as ILayoutDocument;
if (layoutDoc != null)
{
myPresentation.GetModule <IGraphLayoutModule>().Set(layoutDoc.NodeLayouts, layoutDoc.EdgeLayouts);
}
var captionDoc = document as ICaptionDocument;
if (captionDoc != null)
{
var captionModule = myPresentation.GetPropertySetFor <Caption>();
foreach (var caption in captionDoc.Captions)
{
captionModule.Add(caption);
}
}
var tooltipsDoc = document as ToolTipsDocument;
if (tooltipsDoc != null)
{
var toolTipModule = myPresentation.GetPropertySetFor <ToolTipContent>();
foreach (var tip in tooltipsDoc.ToolTips)
{
toolTipModule.Add(tip);
}
}
}
private IEnumerable <NodeWithCaption> GetVisibleNodes()
{
var captionModule = myPresentation.GetPropertySetFor <Caption>();
var transformations = myPresentation.GetModule <ITransformationModule>();
return(transformations.Graph.Nodes
.Where(n => myPresentation.Picking.Pick(n))
.Select(n => new NodeWithCaption(n, captionModule.Get(n.Id).DisplayText)));
}
public static DynamicClusterTransformation DynamicClusters(this IGraphPresentation presentation)
{
Contract.RequiresNotNull(presentation, nameof(presentation));
var transformations = presentation.GetModule <ITransformationModule>();
return(transformations.Items
.OfType <DynamicClusterTransformation>()
.Single());
}
public ClusterFoldingTransformation(IGraphPresentation presentation)
{
myPresentation = presentation;
myNodeMaskModuleObserver = myPresentation.GetModule <INodeMaskModule>().CreateObserver();
myNodeMaskModuleObserver.ModuleChanged += OnGraphVisibilityChanged;
myFoldedClusters = new HashSet <string>();
myComputedEdges = new Dictionary <string, ComputedEdge>();
}
public void Write(IGraphPresentation presentation)
{
Contract.RequiresNotNull(presentation, nameof(presentation));
myWriter.Write(Version);
WriteGraph(presentation.Graph);
WriteNodeMasks(presentation.GetModule <NodeMaskModule>());
WriteTansformations(presentation.GetModule <TransformationModule>());
WriteCaptions(presentation.GetModule <CaptionModule>());
WriteNodeStyles(presentation.GetPropertySetFor <NodeStyle>());
WriteEdgeStyles(presentation.GetPropertySetFor <EdgeStyle>());
// intentionally left out
// - GraphLayoutModule
// - PropertySetModule<Selection>
// - PropertySetModule<ToolTipContent>
}
public void Execute(Action <ClusterFoldingTransformation> action)
{
var transformations = myPresentation.GetModule <ITransformationModule>();
var transformation = transformations.Items
.OfType <ClusterFoldingTransformation>()
.SingleOrDefault();
if (transformation == null)
{
transformation = new ClusterFoldingTransformation(myPresentation);
action(transformation);
transformations.Add(transformation);
}
else
{
action(transformation);
}
}
public void Execute(int numTop)
{
var transformationModule = myPresentation.GetModule <ITransformationModule>();
var nodes = new HashSet <string>(transformationModule.Graph.Nodes
.OrderByDescending(n => n.In.Count)
.Take(numTop)
.Select(n => n.Id));
var nodesToShow = GetNodesWithSiblings(nodes);
var mask = new NodeMask();
mask.Set(nodesToShow);
mask.Label = "Top " + numTop + " most incomings";
var module = myPresentation.GetModule <INodeMaskModule>();
module.Push(mask);
}
private void OnAddCluster(ClusterTreeNode parent)
{
// avoid many intermediate updates
myTransformationsObserver.ModuleChanged -= OnTransformationsChanged;
var newClusterId = Guid.NewGuid().ToString();
var captionModule = myPresentation.GetModule <ICaptionModule>();
captionModule.Add(new Caption(newClusterId, "<new>"));
new ChangeClusterAssignment(myPresentation)
.Execute(t => t.AddCluster(newClusterId));
// start new clusters folded
new ChangeClusterFolding(myPresentation)
.Execute(t => t.Toggle(newClusterId));
// update tree
{
var clusterNode = new ClusterTreeNode(myPresentation)
{
Parent = Root,
Id = newClusterId,
Caption = captionModule.Get(newClusterId).DisplayText,
IsDragAllowed = false
};
Root.Children.Add(clusterNode);
// register for notifications after tree is built to avoid intermediate states getting notified
PropertyChangedEventManager.AddHandler(clusterNode, OnSelectionChanged, PropertySupport.ExtractPropertyName(() => clusterNode.IsSelected));
// nothing ot update
//myNodeClusterCache = null;
}
Root.Children.Single(n => n.Id == newClusterId).IsSelected = true;
myTransformationsObserver.ModuleChanged += OnTransformationsChanged;
}
public void Relayout( IGraphPresentation presentation )
{
GenerateDotFile( presentation );
myConverter.Convert( myDotFile, myPlainFile );
var nodeLayouts = new List<NodeLayout>();
var edgeLayouts = new List<EdgeLayout>();
ParsePlainFile( nodeLayouts, edgeLayouts );
var module = presentation.GetModule<IGraphLayoutModule>();
module.Set( nodeLayouts, edgeLayouts );
}
protected override void OnModelPropertyChanged( string propertyName )
{
if ( propertyName == "Presentation" )
{
if ( myPresentation == Model.Presentation )
{
return;
}
if ( myPresentation != null )
{
myPresentation.GetModule<INodeMaskModule>().CollectionChanged -= OnMasksChanged;
}
myPresentation = Model.Presentation;
if ( myPresentation != null )
{
UpdateMasks();
myPresentation.GetModule<INodeMaskModule>().CollectionChanged += OnMasksChanged;
}
}
}
protected override void OnModelPropertyChanged( string propertyName )
{
if( propertyName == "Presentation" )
{
if( myPresentation == Model.Presentation )
{
return;
}
if( myPresentation != null )
{
myPresentation.GetModule<INodeMaskModule>().CollectionChanged -= OnMasksChanged;
}
myPresentation = Model.Presentation;
Filter = null;
{
myPresentation.GetModule<INodeMaskModule>().CollectionChanged += OnMasksChanged;
}
myPreviewNodes = null;
PreviewNodes.Refresh();
}
}
protected override void OnModelPropertyChanged(string propertyName)
{
if (propertyName == "Model")
{
OnConfigChanged(this, EventArgs.Empty);
}
else if (propertyName == "Presentation")
{
if (myPresentation == Model.Presentation)
{
return;
}
myPresentation = Model.Presentation;
myPresentation.GetModule<INodeMaskModule>().AutoHideAllNodesForShowMasks = true;
if (myPresentation.Graph.Nodes.Count() > 300)
{
var hideAllButOne = new NodeMask();
hideAllButOne.IsShowMask = true;
hideAllButOne.IsApplied = true;
hideAllButOne.Label = "Hide all but one node";
hideAllButOne.Set(myPresentation.Graph.Nodes.Take(1));
myPresentation.GetModule<INodeMaskModule>().Push(hideAllButOne);
OnOpenFilterEditor();
}
OnPropertyChanged("IsEnabled");
}
}
