Compare text

Find the difference between two text files

Real-time editor

Hide whitespace changes

Hide unchanged lines

Disable line wrap

Layout

Diff precision

Text styles

Syntax highlighting

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

autocomplete vs manual

Created last yearDiff never expires

13 removals

Lines
Total
Removed

Characters
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

39 lines

63 additions

Lines
Total
Added

Characters
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

87 lines

internal static List<GraphLayout.Graph> DoGraphAutoLayout(this WorkspaceModel workspace)

/// <summary>

/// This function wraps a few methods on the workspace model layer

/// to set up and run the graph layout algorithm.

/// </summary>

/// <param name="workspace">Workspace on which graph layout will be performed.</param>

/// <param name="originalNodeGUID"></param>

/// <param name="newNodes"></param>

/// <param name="misplacedNodes"></param>

/// <param name="portType"></param>

internal static List<GraphLayout.Graph> DoGraphAutoLayoutAutocomplete(this WorkspaceModel workspace,

Guid originalNodeGUID,

IEnumerable<NodeModel> newNodes,

IEnumerable<NodeModel> misplacedNodes, PortType portType)

{

if (workspace.Nodes.Count() < 2) return null;

var selection = DynamoSelection.Instance.Selection;

const bool isGroupLayout = false;

// Check if all the selected models are groups

bool isGroupLayout = selection.Count > 0 &&

selection.All(x => x is AnnotationModel ||

selection.OfType<AnnotationModel>().Any(g => g.Nodes.Contains(x)));

List<GraphLayout.Graph> layoutSubgraphs;

List<List<GraphLayout.Node>> subgraphClusters;

GenerateCombinedGraph(workspace, isGroupLayout, out layoutSubgraphs, out subgraphClusters);

//only record graph layout undo when it is not node autocomplete

var misplacedGuidSet = misplacedNodes.Select(x => x.GUID).ToHashSet();

RecordUndoGraphLayout(workspace, isGroupLayout, false);

foreach (var node in layoutSubgraphs.First().Nodes)

{

//this is a virtual IsSelected - it doesnt change the workspace node models but marks it as touchable to the algorithm

node.IsSelected = node.Id == originalNodeGUID || misplacedGuidSet.Contains(node.Id);

}

// Generate subgraphs separately for each cluster

subgraphClusters.ForEach(

x => GenerateSeparateSubgraphs(new HashSet<GraphLayout.Node>(x), layoutSubgraphs));

// Deselect all nodes

subgraphClusters.ForEach(c => c.ForEach(x => x.IsSelected = false));

var activeComponents = layoutSubgraphs.Skip(1).ToList();

var targetSubgraph = activeComponents.FirstOrDefault(x => x.Nodes.Any(x => x.Id == originalNodeGUID));

var targetNode = targetSubgraph.Nodes.First(x => x.Id == originalNodeGUID);

// Run layout algorithm for each subgraph

activeComponents.ForEach(g => RunLayoutSubgraph(g, isGroupLayout));

AvoidSubgraphOverlap(layoutSubgraphs);

//original node shouldn't move: move others around

var diffX = targetNode.X - targetNode.InitialX;

var diffY = targetNode.Y - targetNode.InitialY;

foreach (var relatedNode in targetSubgraph.Nodes)

{

relatedNode.X -= diffX;

relatedNode.Y -= diffY;

}

SaveLayoutGraph(workspace, layoutSubgraphs);

if (portType == PortType.Output)

{

double minX = double.MaxValue;

foreach (var relatedNode in targetSubgraph.Nodes)

{

if (newNodes.Any(x => x.GUID == relatedNode.Id))

{

minX = Math.Min(minX, relatedNode.X);

}

double targetMinX = targetNode.X + targetNode.Width + GraphLayout.Graph.HorizontalNodeDistance;

var displacement = minX == double.MaxValue ? 0 : targetMinX - minX;

// Restore the workspace model selection information

foreach (var relatedNode in targetSubgraph.Nodes)

selection.ToList().ForEach(x => x.Select());

{

if (newNodes.Any(x => x.GUID == relatedNode.Id))

{

relatedNode.X += displacement;

}

// right now cluster nodes only work on outputs, single nodes dont need to be relayouted as above

AvoidSubgraphOverlap(layoutSubgraphs, originalNodeGUID);

var maybeUpdateSet = workspace.Nodes.Any(x => x.IsTransient) ?

workspace.Nodes.Where(x => x.GUID == originalNodeGUID || misplacedGuidSet.Contains(x.GUID)) :

workspace.Nodes;

SaveLayoutGraphForNodeAutoComplete(workspace, maybeUpdateSet.ToList(), layoutSubgraphs, originalNodeGUID);

return layoutSubgraphs;

}

Saved diffs

Original text

Open file

internal static List<GraphLayout.Graph> DoGraphAutoLayout(this WorkspaceModel workspace)
        {
            if (workspace.Nodes.Count() < 2) return null;

var selection = DynamoSelection.Instance.Selection;

// Check if all the selected models are groups
            bool isGroupLayout = selection.Count > 0 &&
                selection.All(x => x is AnnotationModel ||
                    selection.OfType<AnnotationModel>().Any(g => g.Nodes.Contains(x)));

List<GraphLayout.Graph> layoutSubgraphs;
            List<List<GraphLayout.Node>> subgraphClusters;

GenerateCombinedGraph(workspace, isGroupLayout, out layoutSubgraphs, out subgraphClusters);

//only record graph layout undo when it is not node autocomplete
            RecordUndoGraphLayout(workspace, isGroupLayout, false);

// Generate subgraphs separately for each cluster
            subgraphClusters.ForEach(
                x => GenerateSeparateSubgraphs(new HashSet<GraphLayout.Node>(x), layoutSubgraphs));

// Deselect all nodes
            subgraphClusters.ForEach(c => c.ForEach(x => x.IsSelected = false));

var activeComponents = layoutSubgraphs.Skip(1).ToList();
            // Run layout algorithm for each subgraph
            activeComponents.ForEach(g => RunLayoutSubgraph(g, isGroupLayout));

AvoidSubgraphOverlap(layoutSubgraphs);

SaveLayoutGraph(workspace, layoutSubgraphs);

// Restore the workspace model selection information
            selection.ToList().ForEach(x => x.Select());

return layoutSubgraphs;
        }

Changed text

Open file

/// <summary>
        /// This function wraps a few methods on the workspace model layer
        /// to set up and run the graph layout algorithm.
        /// </summary>
        /// <param name="workspace">Workspace on which graph layout will be performed.</param>
        /// <param name="originalNodeGUID"></param>
        /// <param name="newNodes"></param>
        /// <param name="misplacedNodes"></param>
        /// <param name="portType"></param>
        internal static List<GraphLayout.Graph> DoGraphAutoLayoutAutocomplete(this WorkspaceModel workspace,
            Guid originalNodeGUID,
            IEnumerable<NodeModel> newNodes,
            IEnumerable<NodeModel> misplacedNodes, PortType portType)
        {
            if (workspace.Nodes.Count() < 2) return null;

const bool isGroupLayout = false;

List<GraphLayout.Graph> layoutSubgraphs;
            List<List<GraphLayout.Node>> subgraphClusters;

GenerateCombinedGraph(workspace, isGroupLayout, out layoutSubgraphs, out subgraphClusters);

var misplacedGuidSet = misplacedNodes.Select(x => x.GUID).ToHashSet();
            foreach (var node in layoutSubgraphs.First().Nodes)
            {
                //this is a virtual IsSelected - it doesnt change the workspace node models but marks it as touchable to the algorithm
                node.IsSelected = node.Id == originalNodeGUID || misplacedGuidSet.Contains(node.Id);
            }

// Generate subgraphs separately for each cluster
            subgraphClusters.ForEach(
                x => GenerateSeparateSubgraphs(new HashSet<GraphLayout.Node>(x), layoutSubgraphs));

// Deselect all nodes
            subgraphClusters.ForEach(c => c.ForEach(x => x.IsSelected = false));

var activeComponents = layoutSubgraphs.Skip(1).ToList();
            var targetSubgraph = activeComponents.FirstOrDefault(x => x.Nodes.Any(x => x.Id == originalNodeGUID));
            var targetNode = targetSubgraph.Nodes.First(x => x.Id == originalNodeGUID);

// Run layout algorithm for each subgraph
            activeComponents.ForEach(g => RunLayoutSubgraph(g, isGroupLayout));

//original node shouldn't move: move others around
            var diffX = targetNode.X - targetNode.InitialX;
            var diffY = targetNode.Y - targetNode.InitialY;
            foreach (var relatedNode in targetSubgraph.Nodes)
            {
                relatedNode.X -= diffX;
                relatedNode.Y -= diffY;
            }

if (portType == PortType.Output)
            {
                double minX = double.MaxValue;
                foreach (var relatedNode in targetSubgraph.Nodes)
                {
                    if (newNodes.Any(x => x.GUID == relatedNode.Id))
                    {
                        minX = Math.Min(minX, relatedNode.X);
                    }
                }
                double targetMinX = targetNode.X + targetNode.Width + GraphLayout.Graph.HorizontalNodeDistance;
                var displacement = minX == double.MaxValue ? 0 : targetMinX - minX;

foreach (var relatedNode in targetSubgraph.Nodes)
                {
                    if (newNodes.Any(x => x.GUID == relatedNode.Id))
                    {
                        relatedNode.X += displacement;
                    }
                }
            }

// right now cluster nodes only work on outputs, single nodes dont need to be relayouted as above

AvoidSubgraphOverlap(layoutSubgraphs, originalNodeGUID);

var maybeUpdateSet = workspace.Nodes.Any(x => x.IsTransient) ?
                workspace.Nodes.Where(x => x.GUID == originalNodeGUID || misplacedGuidSet.Contains(x.GUID)) :
                workspace.Nodes;
            SaveLayoutGraphForNodeAutoComplete(workspace, maybeUpdateSet.ToList(), layoutSubgraphs, originalNodeGUID);

return layoutSubgraphs;
        }