Comparer le texte

Trouver la différence entre deux fichiers texte

Éditeur live

Masquer les espaces

Cacher identiques

Sans retour à la ligne

Vue

Niveau de précision

Styles de texte

Coloration syntaxique

Diffchecker Desktop La façon la plus sécurisée d'utiliser Diffchecker. Obtenez l'application Diffchecker Desktop : vos diffs ne quittent jamais votre ordinateur !Obtenir Desktop

autocomplete vs manual

Créé l’année dernièreLe diff n'expire jamais

13 suppressions

Lignes
Total
Supprimé

Caractères
Total
Supprimé

Pour continuer à utiliser cette fonctionnalité, passez à Diffchecker Pro Voir les prix

39 lignes

63 ajouts

Lignes
Total
Ajouté

Caractères
Total
Ajouté

Pour continuer à utiliser cette fonctionnalité, passez à Diffchecker Pro Voir les prix

87 lignes

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érences enregistrées

Texte d'origine

Ouvrir un fichier

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

Texte modifié

Ouvrir un fichier

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