Confronta il testo

Trova la differenza tra due file di testo

Editor live

Nascondi spazi bianchi

Comprimi invariate

Senza a capo

Layout

Livello di dettaglio

Stili testo

Evidenziazione sintassi

Diffchecker Desktop Il modo più sicuro per usare Diffchecker. Ottieni l'app Diffchecker Desktop: i tuoi diff non lasciano mai il tuo computer!Ottieni Desktop

autocomplete vs manual

Creato anno scorsoIl diff non scade mai

13 rimozioni

Linee
Totale
Rimosso

Caratteri
Totale
Rimosso

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

39 linee

63 aggiunte

Linee
Totale
Aggiunto

Caratteri
Totale
Aggiunto

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

87 linee

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;

}

Diff salvati

Testo originale

Apri 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;
        }

Testo modificato

Apri 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;
        }