DynamoDS
diff --git a/‎src/DynamoCore/Core/UndoRedoRecorder.cs
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions b/‎src/DynamoCore/Core/UndoRedoRecorder.cs
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions
diff --git a/‎src/DynamoCore/Graph/Workspaces/HomeWorkspaceModel.cs
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎src/DynamoCore/Graph/Workspaces/HomeWorkspaceModel.cs
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎src/DynamoCore/Graph/Workspaces/NodesToCodeExtensions.cs
Copy file name to clipboard
+3-1Lines changed: 3 additions & 1 deletion b/‎src/DynamoCore/Graph/Workspaces/NodesToCodeExtensions.cs
Copy file name to clipboard
+3-1Lines changed: 3 additions & 1 deletion
diff --git a/‎src/DynamoCore/Graph/Workspaces/WorkspaceModel.cs
Copy file name to clipboard
+48Lines changed: 48 additions & 0 deletions b/‎src/DynamoCore/Graph/Workspaces/WorkspaceModel.cs
Copy file name to clipboard
+48Lines changed: 48 additions & 0 deletions
diff --git a/‎src/DynamoCore/Models/DynamoModel.cs
Copy file name to clipboard
+111-108Lines changed: 111 additions & 108 deletions b/‎src/DynamoCore/Models/DynamoModel.cs
Copy file name to clipboard
+111-108Lines changed: 111 additions & 108 deletions
@@ -5,6 +5,7 @@
 using Dynamo.Graph;
 using Dynamo.Graph.Connectors;
 using Dynamo.Graph.Nodes;
+using Dynamo.Graph.Workspaces;
 
 namespace Dynamo.Core
 {
@@ -358,6 +359,7 @@ private void UndoActionGroup(XmlElement actionGroup)
             // 
             var actions = actionGroup.ChildNodes.Cast<XmlNode>().ToList();
 
+            using ((undoClient as WorkspaceModel)?.BeginDelayedGraphExecution())
             // In undo scenario, user actions are undone in the reversed order 
             // that they were done (due to inter-dependencies among components).
             // 
@@ -411,6 +413,7 @@ private void RedoActionGroup(XmlElement actionGroup)
             // See "UndoActionGroup" above for details why this duplicate.
             var actions = actionGroup.ChildNodes.Cast<XmlNode>().ToList();
 
+            using ((undoClient as WorkspaceModel)?.BeginDelayedGraphExecution())
             // Redo operation is the reversed of undo operation, naturally.
             for (int index = actions.Count - 1; index >= 0; index--)
             {
 
@@ -346,10 +346,10 @@ internal override void RequestRun()
                 // We will be needing a separate variable(boolean flag) to check whether run can be enabled from external applications
                 // and not confuse it with the internal flag RunEnabled which is associated with the Run button in Dynamo. 
                 // Make this RunSettings.RunEnabled private, introduce the new flag and remove the "executingTask" variable. 
-                if (RunSettings.RunEnabled || executingTask)
+                if ((RunSettings.RunEnabled || executingTask) && !DelayGraphExecution)
                 {
                     Run();
-                }   
+                }
             }
         }
 
@@ -665,7 +665,7 @@ public void Run()
             // are compiled first before the home workspace gets evaluated.
             // 
             EngineController.ProcessPendingCustomNodeSyncData(scheduler);
-
+            
             var task = new UpdateGraphAsyncTask(scheduler, verboseLogging);
             if (task.Initialize(EngineController, this))
             {
 
@@ -1,4 +1,5 @@
-using Dynamo.Engine;
+using Dynamo.Core;
+using Dynamo.Engine;
 using Dynamo.Engine.NodeToCode;
 using Dynamo.Graph.Connectors;
 using Dynamo.Graph.Nodes;
@@ -28,6 +29,7 @@ internal static void ConvertNodesToCodeInternal(this WorkspaceModel workspace, E
             //UndoRedo Action Group----------------------------------------------
             NodeToCodeUndoHelper undoHelper = new NodeToCodeUndoHelper();
 
+            using(workspace.BeginDelayedGraphExecution())
             foreach (var nodeList in cliques)
             {
                 //Create two dictionarys to store the details of the external connections that have to
 
@@ -134,6 +134,39 @@ public override bool Equals(object obj)
     /// </summary>
     public abstract partial class WorkspaceModel : NotificationObject, ILocatable, IUndoRedoRecorderClient, ILogSource, IDisposable, IWorkspaceModel
     {
+        #region nested classes
+
+        /// <summary>
+        /// This class enables the delay of graph execution.
+        /// Use instances of this class to specify a code scope in which you want graph execution to be delayed. 
+        /// Class is thread safe, although behavior is not well defined. 
+        /// Nested instance of this class do not have a well defined behavior.
+        /// </summary>
+        internal class DelayedGraphExecution : IDisposable
+        {
+            private readonly WorkspaceModel workspace;
+            private static readonly object stateMutex = new object();
+
+            public DelayedGraphExecution(WorkspaceModel wModel)
+            {
+                workspace = wModel;
+                lock (stateMutex)
+                {
+                    workspace.delayGraphExecutionCounter++;
+                }
+            }
+
+            public virtual void Dispose()
+            {
+                lock (stateMutex)
+                {
+                    workspace.delayGraphExecutionCounter--;
+                }
+                workspace.RequestRun();
+            }
+        }
+        #endregion
+
         #region private/internal members
 
         /// <summary>
@@ -183,6 +216,13 @@ internal int CurrentPasteOffset
         protected Guid guid;
         private HashSet<Guid> dependencies = new HashSet<Guid>();
 
+        private int delayGraphExecutionCounter = 0;
+
+        /// <summary>
+        /// Whether or not to delay graph execution.
+        /// </summary>
+        internal protected bool DelayGraphExecution => delayGraphExecutionCounter > 0;
+
         /// <summary>
         /// This is set to true after a workspace is added.
         /// This is set to false, if the workspace is cleared or disposed.
@@ -2152,5 +2192,13 @@ internal void CreateNewExtensionData(string uniqueId, string name, string versio
             var extensionData = new ExtensionData(uniqueId, name, version, data);
             ExtensionData.Add(extensionData);
         }
+        
+        /// <summary>
+        ///     Returns a DelayedGraphExecution object.
+        /// </summary>
+        internal DelayedGraphExecution BeginDelayedGraphExecution()
+        {
+            return new DelayedGraphExecution(this);
+        }
     }
 }
@@ -2387,143 +2387,146 @@ public void Paste(Point2D targetPoint, bool useOffset = true)
 
             // Create the new NodeModel's
             var newNodeModels = new List<NodeModel>();
-            foreach (var node in nodes)
+            using(CurrentWorkspace.BeginDelayedGraphExecution())
             {
-                NodeModel newNode;
-
-                if (CurrentWorkspace is HomeWorkspaceModel && (node is Symbol || node is Output))
-                {
-                    var symbol = (node is Symbol
-                        ? (node as Symbol).InputSymbol
-                        : (node as Output).Symbol);
-                    var code = (string.IsNullOrEmpty(symbol) ? "x" : symbol) + ";";
-                    newNode = new CodeBlockNodeModel(code, node.X, node.Y, LibraryServices, CurrentWorkspace.ElementResolver);
-                }
-                else
+                foreach (var node in nodes)
                 {
-                    var dynEl = node.Serialize(xmlDoc, SaveContext.Copy);
-                    newNode = NodeFactory.CreateNodeFromXml(dynEl, SaveContext.Copy, CurrentWorkspace.ElementResolver);
-                }
+                    NodeModel newNode;
 
-                var lacing = node.ArgumentLacing.ToString();
-                newNode.UpdateValue(new UpdateValueParams("ArgumentLacing", lacing));
-                if (!string.IsNullOrEmpty(node.Name) && !(node is Symbol) && !(node is Output))
-                    newNode.Name = node.Name;
+                    if (CurrentWorkspace is HomeWorkspaceModel && (node is Symbol || node is Output))
+                    {
+                        var symbol = (node is Symbol
+                            ? (node as Symbol).InputSymbol
+                            : (node as Output).Symbol);
+                        var code = (string.IsNullOrEmpty(symbol) ? "x" : symbol) + ";";
+                        newNode = new CodeBlockNodeModel(code, node.X, node.Y, LibraryServices, CurrentWorkspace.ElementResolver);
+                    }
+                    else
+                    {
+                        var dynEl = node.Serialize(xmlDoc, SaveContext.Copy);
+                        newNode = NodeFactory.CreateNodeFromXml(dynEl, SaveContext.Copy, CurrentWorkspace.ElementResolver);
+                    }
 
-                newNode.Width = node.Width;
-                newNode.Height = node.Height;
+                    var lacing = node.ArgumentLacing.ToString();
+                    newNode.UpdateValue(new UpdateValueParams("ArgumentLacing", lacing));
+                    if (!string.IsNullOrEmpty(node.Name) && !(node is Symbol) && !(node is Output))
+                        newNode.Name = node.Name;
 
-                modelLookup.Add(node.GUID, newNode);
+                    newNode.Width = node.Width;
+                    newNode.Height = node.Height;
 
-                newNodeModels.Add(newNode);
-            }
+                    modelLookup.Add(node.GUID, newNode);
 
-            var newItems = newNodeModels.Concat<ModelBase>(newNoteModels);
+                    newNodeModels.Add(newNode);
+                }
 
-            var shiftX = targetPoint.X - newItems.Min(item => item.X);
-            var shiftY = targetPoint.Y - newItems.Min(item => item.Y);
-            var offset = useOffset ? CurrentWorkspace.CurrentPasteOffset : 0;
+                var newItems = newNodeModels.Concat<ModelBase>(newNoteModels);
 
-            foreach (var model in newItems)
-            {
-                model.X = model.X + shiftX + offset;
-                model.Y = model.Y + shiftY + offset;
-            }
+                var shiftX = targetPoint.X - newItems.Min(item => item.X);
+                var shiftY = targetPoint.Y - newItems.Min(item => item.Y);
+                var offset = useOffset ? CurrentWorkspace.CurrentPasteOffset : 0;
 
-            // Add the new NodeModel's to the Workspace
-            foreach (var newNode in newNodeModels)
-            {
-                CurrentWorkspace.AddAndRegisterNode(newNode, false);
-                createdModels.Add(newNode);
-            }
+                foreach (var model in newItems)
+                {
+                    model.X = model.X + shiftX + offset;
+                    model.Y = model.Y + shiftY + offset;
+                }
 
-            // TODO: is this required?
-            OnRequestLayoutUpdate(this, EventArgs.Empty);
+                // Add the new NodeModel's to the Workspace
+                foreach (var newNode in newNodeModels)
+                {
+                    CurrentWorkspace.AddAndRegisterNode(newNode, false);
+                    createdModels.Add(newNode);
+                }
 
-            // Add the new NoteModel's to the Workspace
-            foreach (var newNote in newNoteModels)
-            {
-                CurrentWorkspace.AddNote(newNote, false);
-                createdModels.Add(newNote);
-            }
+                // TODO: is this required?
+                OnRequestLayoutUpdate(this, EventArgs.Empty);
+
+                // Add the new NoteModel's to the Workspace
+                foreach (var newNote in newNoteModels)
+                {
+                    CurrentWorkspace.AddNote(newNote, false);
+                    createdModels.Add(newNote);
+                }
 
-            ModelBase start;
-            ModelBase end;
-            var newConnectors =
-                from c in connectors
+                ModelBase start;
+                ModelBase end;
+                var newConnectors =
+                    from c in connectors
 
-                    // If the guid is in nodeLookup, then we connect to the new pasted node. Otherwise we
-                    // re-connect to the original.
+                        // If the guid is in nodeLookup, then we connect to the new pasted node. Otherwise we
+                        // re-connect to the original.
                 let startNode =
-                    modelLookup.TryGetValue(c.Start.Owner.GUID, out start)
-                        ? start as NodeModel
-                        : CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.Start.Owner.GUID)
-                let endNode =
-                    modelLookup.TryGetValue(c.End.Owner.GUID, out end)
-                        ? end as NodeModel
-                        : CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.End.Owner.GUID)
+                        modelLookup.TryGetValue(c.Start.Owner.GUID, out start)
+                            ? start as NodeModel
+                            : CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.Start.Owner.GUID)
+                    let endNode =
+                        modelLookup.TryGetValue(c.End.Owner.GUID, out end)
+                            ? end as NodeModel
+                            : CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.End.Owner.GUID)
 
                 // Don't make a connector if either end is null.
                 where startNode != null && endNode != null
-                select
-                    ConnectorModel.Make(startNode, endNode, c.Start.Index, c.End.Index);
+                    select
+                        ConnectorModel.Make(startNode, endNode, c.Start.Index, c.End.Index);
 
-            createdModels.AddRange(newConnectors);
+                createdModels.AddRange(newConnectors);
 
-            //Grouping depends on the selected node models.
-            //so adding the group after nodes / notes are added to workspace.
-            //select only those nodes that are part of a group.
-            var newAnnotations = new List<AnnotationModel>();
-            foreach (var annotation in annotations)
-            {
-                var annotationNodeModel = new List<NodeModel>();
-                var annotationNoteModel = new List<NoteModel>();
-                // some models can be deleted after copying them,
-                // so they need to be in pasted annotation as well
-                var modelsToRestore = annotation.DeletedModelBases.Intersect(ClipBoard);
-                var modelsToAdd = annotation.Nodes.Concat(modelsToRestore);
-                // checked condition here that supports pasting of multiple groups
-                foreach (var models in modelsToAdd)
+                //Grouping depends on the selected node models.
+                //so adding the group after nodes / notes are added to workspace.
+                //select only those nodes that are part of a group.
+                var newAnnotations = new List<AnnotationModel>();
+                foreach (var annotation in annotations)
                 {
-                    ModelBase mbase;
-                    modelLookup.TryGetValue(models.GUID, out mbase);
-                    if (mbase is NodeModel)
+                    var annotationNodeModel = new List<NodeModel>();
+                    var annotationNoteModel = new List<NoteModel>();
+                    // some models can be deleted after copying them,
+                    // so they need to be in pasted annotation as well
+                    var modelsToRestore = annotation.DeletedModelBases.Intersect(ClipBoard);
+                    var modelsToAdd = annotation.Nodes.Concat(modelsToRestore);
+                    // checked condition here that supports pasting of multiple groups
+                    foreach (var models in modelsToAdd)
                     {
-                        annotationNodeModel.Add(mbase as NodeModel);
+                        ModelBase mbase;
+                        modelLookup.TryGetValue(models.GUID, out mbase);
+                        if (mbase is NodeModel)
+                        {
+                            annotationNodeModel.Add(mbase as NodeModel);
+                        }
+                        if (mbase is NoteModel)
+                        {
+                            annotationNoteModel.Add(mbase as NoteModel);
+                        }
                     }
-                    if (mbase is NoteModel)
+
+                    var annotationModel = new AnnotationModel(annotationNodeModel, annotationNoteModel)
                     {
-                        annotationNoteModel.Add(mbase as NoteModel);
-                    }
+                        GUID = Guid.NewGuid(),
+                        AnnotationText = annotation.AnnotationText,
+                        Background = annotation.Background,
+                        FontSize = annotation.FontSize
+                    };
+
+                    newAnnotations.Add(annotationModel);
                 }
 
-                var annotationModel = new AnnotationModel(annotationNodeModel, annotationNoteModel)
+                // Add the new Annotation's to the Workspace
+                foreach (var newAnnotation in newAnnotations)
                 {
-                    GUID = Guid.NewGuid(),
-                    AnnotationText = annotation.AnnotationText,
-                    Background = annotation.Background,
-                    FontSize = annotation.FontSize
-                };
-
-                newAnnotations.Add(annotationModel);
-            }
-
-            // Add the new Annotation's to the Workspace
-            foreach (var newAnnotation in newAnnotations)
-            {
-                CurrentWorkspace.AddAnnotation(newAnnotation);
-                createdModels.Add(newAnnotation);
-                AddToSelection(newAnnotation);
-            }
+                    CurrentWorkspace.AddAnnotation(newAnnotation);
+                    createdModels.Add(newAnnotation);
+                    AddToSelection(newAnnotation);
+                }
 
-            // adding an annotation overrides selection, so add nodes and notes after
-            foreach (var item in newItems)
-            {
-                AddToSelection(item);
-            }
+                // adding an annotation overrides selection, so add nodes and notes after
+                foreach (var item in newItems)
+                {
+                    AddToSelection(item);
+                }
 
-            // Record models that are created as part of the command.
-            CurrentWorkspace.RecordCreatedModels(createdModels);
+                // Record models that are created as part of the command.
+                CurrentWorkspace.RecordCreatedModels(createdModels);
+            }    
         }
 
         /// <summary>
Original file line number	Diff line number	Diff line change
`@@ -346,10 +346,10 @@ internal override void RequestRun()`
`346`	`346`	`// We will be needing a separate variable(boolean flag) to check whether run can be enabled from external applications`
`347`	`347`	`// and not confuse it with the internal flag RunEnabled which is associated with the Run button in Dynamo.`
`348`	`348`	`// Make this RunSettings.RunEnabled private, introduce the new flag and remove the "executingTask" variable.`
`349`		`- if (RunSettings.RunEnabled \|\| executingTask)`
	`349`	`+ if ((RunSettings.RunEnabled \|\| executingTask) && !DelayGraphExecution)`
`350`	`350`	`{`
`351`	`351`	`Run();`
`352`		`- }`
	`352`	`+ }`
`353`	`353`	`}`
`354`	`354`	`}`
`355`	`355`
`@@ -665,7 +665,7 @@ public void Run()`
`665`	`665`	`// are compiled first before the home workspace gets evaluated.`
`666`	`666`	`//`
`667`	`667`	`EngineController.ProcessPendingCustomNodeSyncData(scheduler);`
`668`		`-`
	`668`	`+`
`669`	`669`	`var task = new UpdateGraphAsyncTask(scheduler, verboseLogging);`
`670`	`670`	`if (task.Initialize(EngineController, this))`
`671`	`671`	`{`