Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live

Ocultar espacios en blanco

Ocultar sin cambios

Sin ajuste de línea

Vista

Nivel de detalle

Estilos de texto

Resaltado de sintaxis

Diffchecker Desktop La forma más segura de usar Diffchecker. ¡Obtén la app de Diffchecker Desktop: tus diffs nunca salen de tu computadora!Obtener Desktop

autocomplete vs manual

Creado el año pasadoEl diff nunca expira

13 eliminaciones

Líneas
Total
Eliminado

Caracteres
Total
Eliminado

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

39 líneas

63 adiciones

Líneas
Total
Añadido

Caracteres
Total
Añadido

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

87 líneas

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;

}

Diferencias guardadas

Texto original

Abrir archivo

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

Texto modificado

Abrir archivo

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