internal void AddModel(DummyModel model)
{
models.Add(model);
undoRecorder.BeginActionGroup();
undoRecorder.RecordCreationForUndo(model);
undoRecorder.EndActionGroup();
}
public void TestBeginActionGroup00()
{
Assert.Throws <InvalidOperationException>(() =>
{
recorder.BeginActionGroup();
recorder.BeginActionGroup(); // Exception.
});
}
internal void RecordCreatedModel(ModelBase model)
{
if (null == model)
{
return;
}
using (undoRecorder.BeginActionGroup())
{
undoRecorder.RecordCreationForUndo(model);
}
}
public static void RecordModelsForUndo(Dictionary <ModelBase, UndoRedoRecorder.UserAction> models, UndoRedoRecorder recorder)
{
if (null == recorder)
{
return;
}
if (!ShouldProceedWithRecording(models))
{
return;
}
using (recorder.BeginActionGroup())
{
foreach (var modelPair in models)
{
switch (modelPair.Value)
{
case UndoRedoRecorder.UserAction.Creation:
recorder.RecordCreationForUndo(modelPair.Key);
break;
case UndoRedoRecorder.UserAction.Deletion:
recorder.RecordDeletionForUndo(modelPair.Key);
break;
case UndoRedoRecorder.UserAction.Modification:
recorder.RecordModificationForUndo(modelPair.Key);
break;
}
}
}
}
/// <summary>
/// TODO(Ben): This method is exposed this way for external codes (e.g.
/// the DragCanvas) to record models before they are modified. This is
/// by no means ideal. The ideal case of course is for ALL codes that
/// end up modifying models to be folded back into WorkspaceViewModel in
/// the form of commands. These commands then internally record those
/// affected models before updating them. We need this method to be gone
/// sooner than later.
/// </summary>
/// <param name="models">The models to be recorded for undo.</param>
///
internal void RecordModelsForModification(List <ModelBase> models)
{
if (null == undoRecorder)
{
return;
}
if (!ShouldProceedWithRecording(models))
{
return;
}
undoRecorder.BeginActionGroup();
{
foreach (ModelBase model in models)
{
undoRecorder.RecordModificationForUndo(model);
}
}
undoRecorder.EndActionGroup();
}
internal static void RecordModelsForUndo(Dictionary <ModelBase, UndoRedoRecorder.UserAction> models, UndoRedoRecorder recorder)
{
if (null == recorder)
{
return;
}
if (!ShouldProceedWithRecording(models))
{
return;
}
if (null != savedModels)
{
// Before an existing connector is reconnected, we have one action group
// which records the deletion of the connector. Pop that out so that we can
// record the deletion and reconnection in one action group.
recorder.PopFromUndoGroup();
}
using (recorder.BeginActionGroup())
{
if (null != savedModels)
{
foreach (var modelPair in savedModels)
{
recorder.RecordDeletionForUndo(modelPair);
}
savedModels = null;
}
foreach (var modelPair in models)
{
switch (modelPair.Value)
{
case UndoRedoRecorder.UserAction.Creation:
recorder.RecordCreationForUndo(modelPair.Key);
break;
case UndoRedoRecorder.UserAction.Deletion:
recorder.RecordDeletionForUndo(modelPair.Key);
break;
case UndoRedoRecorder.UserAction.Modification:
recorder.RecordModificationForUndo(modelPair.Key);
break;
}
}
}
}
public void SetCodeContent(string newCode, UndoRedoRecorder recorder)
{
if (code != null && code.Equals(newCode))
{
return;
}
if (newCode == null)
{
code = null;
}
else
{
string errorMessage = string.Empty;
string warningMessage = string.Empty;
using (recorder.BeginActionGroup())
{
var inportConnections = new OrderedDictionary();
var outportConnections = new OrderedDictionary();
//Save the connectors so that we can recreate them at the correct positions
SaveAndDeleteConnectors(inportConnections, outportConnections, recorder);
code = newCode;
ProcessCode(ref errorMessage, ref warningMessage);
//Recreate connectors that can be reused
LoadAndCreateConnectors(inportConnections, outportConnections, recorder);
}
RaisePropertyChanged("Code");
ForceReExecuteOfNode = true;
OnAstUpdated();
ReportPosition();
ClearRuntimeError();
if (!string.IsNullOrEmpty(errorMessage))
{
Error(errorMessage);
}
else if (!string.IsNullOrEmpty(warningMessage))
{
Warning(warningMessage);
}
}
}
/// <summary>
/// TODO(Ben): This method is exposed this way for external codes (e.g.
/// the DragCanvas) to record models before they are modified. This is
/// by no means ideal. The ideal case of course is for ALL codes that
/// end up modifying models to be folded back into WorkspaceViewModel in
/// the form of commands. These commands then internally record those
/// affected models before updating them. We need this method to be gone
/// sooner than later.
/// </summary>
/// <param name="models">The models to be recorded for undo.</param>
/// <param name="recorder"></param>
internal static void RecordModelsForModification(List <ModelBase> models, UndoRedoRecorder recorder)
{
if (null == recorder)
{
return;
}
if (!ShouldProceedWithRecording(models))
{
return;
}
using (recorder.BeginActionGroup())
{
foreach (var model in models)
{
recorder.RecordModificationForUndo(model);
}
}
}
/// <summary>
/// Record all actions in recorder.
/// </summary>
/// <param name="recorder"></param>
public void ApplyActions(UndoRedoRecorder recorder)
{
using (recorder.BeginActionGroup())
{
foreach (var item in recordedActions)
{
var model = item.Item1;
var action = item.Item2;
if (action == UndoRedoRecorder.UserAction.Creation)
{
recorder.RecordCreationForUndo(model);
}
else if (action == UndoRedoRecorder.UserAction.Deletion)
{
recorder.RecordDeletionForUndo(model);
}
}
}
}
private void CommitChanges(UndoRedoRecorder recorder)
{
// Code block editor can lose focus in many scenarios (e.g. switching
// of tabs or application), if there has not been any changes, do not
// commit the change.
//
if (!nodeModel.Code.Equals(InnerTextEditor.Text))
{
nodeViewModel.DynamoViewModel.ExecuteCommand(
new DynCmd.UpdateModelValueCommand(
nodeViewModel.WorkspaceViewModel.Model.Guid,
nodeModel.GUID,
"Code", InnerTextEditor.Text));
}
if (createdForNewCodeBlock)
{
// If this editing was started due to a new code block node,
// then by this point there would have been two action groups
// recorded on the undo-stack: one for node creation, and
// another for node editing (as part of ExecuteCommand above).
// Pop off the two action groups...
//
recorder.PopFromUndoGroup(); // Pop off modification action.
// Note that due to various external factors a code block node
// loaded from file may be created empty. In such cases, the
// creation step would not have been recorded (there was no
// explicit creation of the node, it was created from loading
// of a file), and nothing should be popped off of the undo stack.
if (recorder.CanUndo)
{
recorder.PopFromUndoGroup(); // Pop off creation action.
}
// ... and record this new node as new creation.
using (recorder.BeginActionGroup())
{
recorder.RecordCreationForUndo(nodeModel);
}
}
}
/// <summary>
/// Collapse a set of nodes in a given workspace. Has the side effects of prompting the user
/// first in order to obtain the name and category for the new node,
/// writes the function to a dyf file, adds it to the FunctionDict, adds it to search, and compiles and
/// places the newly created symbol (defining a lambda) in the Controller's FScheme Environment.
/// </summary>
/// <param name="selectedNodes"> The function definition for the user-defined node </param>
/// <param name="currentWorkspace"> The workspace where</param>
/// <param name="args"></param>
public static void Collapse(IEnumerable <NodeModel> selectedNodes, WorkspaceModel currentWorkspace, FunctionNamePromptEventArgs args = null)
{
var selectedNodeSet = new HashSet <NodeModel>(selectedNodes);
if (args == null || !args.Success)
{
args = new FunctionNamePromptEventArgs();
dynSettings.Controller.DynamoViewModel.OnRequestsFunctionNamePrompt(null, args);
//if (!dynSettings.Controller.DynamoViewModel.ShowNewFunctionDialog(ref newNodeName, ref newNodeCategory))
if (!args.Success)
{
return;
}
}
// Note that undoable actions are only recorded for the "currentWorkspace",
// the nodes which get moved into "newNodeWorkspace" are not recorded for undo,
// even in the new workspace. Their creations will simply be treated as part of
// the opening of that new workspace (i.e. when a user opens a file, she will
// not expect the nodes that show up to be undoable).
//
// After local nodes are moved into "newNodeWorkspace" as the result of
// conversion, if user performs an undo, new set of nodes will be created in
// "currentWorkspace" (not moving those nodes in the "newNodeWorkspace" back
// into "currentWorkspace"). In another word, undo recording is on a per-
// workspace basis, it does not work across different workspaces.
//
UndoRedoRecorder undoRecorder = currentWorkspace.UndoRecorder;
undoRecorder.BeginActionGroup();
var newNodeWorkspace = new CustomNodeWorkspaceModel(args.Name, args.Category, args.Description, 0, 0)
{
WatchChanges = false,
HasUnsavedChanges = true
};
var newNodeDefinition = new CustomNodeDefinition(Guid.NewGuid())
{
WorkspaceModel = newNodeWorkspace
};
currentWorkspace.DisableReporting();
#region Determine Inputs and Outputs
//Step 1: determine which nodes will be inputs to the new node
var inputs = new HashSet <Tuple <NodeModel, int, Tuple <int, NodeModel> > >(
selectedNodeSet.SelectMany(
node => Enumerable.Range(0, node.InPortData.Count).Where(node.HasConnectedInput)
.Select(data => Tuple.Create(node, data, node.Inputs[data]))
.Where(input => !selectedNodeSet.Contains(input.Item3.Item2))));
var outputs = new HashSet <Tuple <NodeModel, int, Tuple <int, NodeModel> > >(
selectedNodeSet.SelectMany(
node => Enumerable.Range(0, node.OutPortData.Count).Where(node.HasOutput).SelectMany(
data => node.Outputs[data]
.Where(output => !selectedNodeSet.Contains(output.Item2))
.Select(output => Tuple.Create(node, data, output)))));
#endregion
#region Detect 1-node holes (higher-order function extraction)
var curriedNodeArgs =
new HashSet <NodeModel>(
inputs
.Select(x => x.Item3.Item2)
.Intersect(outputs.Select(x => x.Item3.Item2)))
.Select(
outerNode =>
{
var node = new Apply1();
//MVVM : Don't make direct reference to view here
//MVVM: no reference to view here
//dynNodeView nodeUI = node.NodeUI;
var elNameAttrib =
node.GetType().GetCustomAttributes(typeof(NodeNameAttribute), true)[0] as
NodeNameAttribute;
if (elNameAttrib != null)
{
node.NickName = elNameAttrib.Name;
}
node.GUID = Guid.NewGuid();
//store the element in the elements list
newNodeWorkspace.Nodes.Add(node);
node.WorkSpace = newNodeWorkspace;
node.DisableReporting();
//MVVM : Can't set view location here
//dynSettings.Bench.WorkBench.Children.Add(nodeUI);
//Place it in an appropriate spot
//Canvas.SetLeft(nodeUI, Canvas.GetLeft(outerNode.NodeUI));
//Canvas.SetTop(nodeUI, Canvas.GetTop(outerNode.NodeUI));
node.X = outerNode.X;
node.Y = outerNode.Y;
//Fetch all input ports
// in order
// that have inputs
// and whose input comes from an inner node
List <int> inPortsConnected = Enumerable.Range(0, outerNode.InPortData.Count)
.Where(
x =>
outerNode.HasInput(x) &&
selectedNodeSet.Contains(
outerNode.Inputs[x].Item2))
.ToList();
var nodeInputs = outputs
.Where(output => output.Item3.Item2 == outerNode)
.Select(
output =>
new
{
InnerNodeInputSender = output.Item1,
OuterNodeInPortData = output.Item3.Item1
}).ToList();
nodeInputs.ForEach(_ => node.AddInput());
node.RegisterAllPorts();
return(new
{
OuterNode = outerNode,
InnerNode = node,
Outputs = inputs.Where(input => input.Item3.Item2 == outerNode)
.Select(input => input.Item3.Item1),
Inputs = nodeInputs,
OuterNodePortDataList = inPortsConnected
});
}).ToList();
#endregion
#region UI Positioning Calculations
double avgX = selectedNodeSet.Average(node => node.X);
double avgY = selectedNodeSet.Average(node => node.Y);
double leftMost = selectedNodeSet.Min(node => node.X);
double topMost = selectedNodeSet.Min(node => node.Y);
double rightMost = selectedNodeSet.Max(node => node.X + node.Width);
#endregion
#region Handle full selected connectors
// Step 2: Determine all the connectors whose start/end owners are
// both in the selection set, and then move them from the current
// workspace into the new workspace.
var fullySelectedConns = new HashSet <ConnectorModel>(
currentWorkspace.Connectors.Where(conn =>
{
bool startSelected = selectedNodeSet.Contains(conn.Start.Owner);
bool endSelected = selectedNodeSet.Contains(conn.End.Owner);
return(startSelected && endSelected);
}));
foreach (var ele in fullySelectedConns)
{
undoRecorder.RecordDeletionForUndo(ele);
currentWorkspace.Connectors.Remove(ele);
}
#endregion
#region Handle partially selected connectors
// Step 3: Partially selected connectors (either one of its start
// and end owners is in the selection) are to be destroyed.
var partiallySelectedConns =
currentWorkspace.Connectors.Where(
conn =>
selectedNodeSet.Contains(conn.Start.Owner) ||
selectedNodeSet.Contains(conn.End.Owner)).ToList();
foreach (ConnectorModel connector in partiallySelectedConns)
{
undoRecorder.RecordDeletionForUndo(connector);
connector.NotifyConnectedPortsOfDeletion();
currentWorkspace.Connectors.Remove(connector);
}
#endregion
#region Transfer nodes and connectors to new workspace
// Step 4: move all nodes to new workspace remove from old
foreach (var ele in selectedNodeSet)
{
undoRecorder.RecordDeletionForUndo(ele);
ele.SaveResult = false;
currentWorkspace.Nodes.Remove(ele);
ele.WorkSpace = newNodeWorkspace;
}
// add to new
newNodeWorkspace.Nodes.AddRange(selectedNodeSet);
newNodeWorkspace.Connectors.AddRange(fullySelectedConns);
double leftShift = leftMost - 250;
foreach (NodeModel node in newNodeWorkspace.Nodes)
{
node.X = node.X - leftShift;
node.Y = node.Y - topMost;
}
#endregion
foreach (var node in newNodeWorkspace.Nodes)
{
node.DisableReporting();
}
#region Process inputs
var inConnectors = new List <Tuple <NodeModel, int> >();
var uniqueInputSenders = new Dictionary <Tuple <NodeModel, int>, Symbol>();
//Step 3: insert variables (reference step 1)
foreach (var input in Enumerable.Range(0, inputs.Count).Zip(inputs, Tuple.Create))
{
int inputIndex = input.Item1;
NodeModel inputReceiverNode = input.Item2.Item1;
int inputReceiverData = input.Item2.Item2;
NodeModel inputNode = input.Item2.Item3.Item2;
int inputData = input.Item2.Item3.Item1;
Symbol node;
var key = Tuple.Create(inputNode, inputData);
if (uniqueInputSenders.ContainsKey(key))
{
node = uniqueInputSenders[key];
}
else
{
//MVVM : replace NodeUI reference with node
inConnectors.Add(Tuple.Create(inputNode, inputData));
//Create Symbol Node
node = new Symbol
{
InputSymbol = inputReceiverNode.InPortData[inputReceiverData].NickName
};
//MVVM : Don't make direct reference to view here
//dynNodeView nodeUI = node.NodeUI;
var elNameAttrib =
node.GetType().GetCustomAttributes(typeof(NodeNameAttribute), true)[0] as NodeNameAttribute;
if (elNameAttrib != null)
{
node.NickName = elNameAttrib.Name;
}
node.GUID = Guid.NewGuid();
//store the element in the elements list
newNodeWorkspace.Nodes.Add(node);
node.WorkSpace = newNodeWorkspace;
node.DisableReporting();
node.X = 0;
node.Y = inputIndex * (50 + node.Height);
uniqueInputSenders[key] = node;
}
var curriedNode = curriedNodeArgs.FirstOrDefault(x => x.OuterNode == inputNode);
if (curriedNode == null)
{
var conn1 = ConnectorModel.Make(node,
inputReceiverNode,
0,
inputReceiverData,
PortType.INPUT);
if (conn1 != null)
{
newNodeWorkspace.Connectors.Add(conn1);
}
}
else
{
//Connect it to the applier
var conn = ConnectorModel.Make(node,
curriedNode.InnerNode,
0,
0,
PortType.INPUT);
if (conn != null)
{
newNodeWorkspace.Connectors.Add(conn);
}
//Connect applier to the inner input receive
var conn2 = ConnectorModel.Make(
curriedNode.InnerNode,
inputReceiverNode,
0,
inputReceiverData,
PortType.INPUT);
if (conn2 != null)
{
newNodeWorkspace.Connectors.Add(conn2);
}
}
}
#endregion
#region Process outputs
//List of all inner nodes to connect an output. Unique.
var outportList = new List <Tuple <NodeModel, int> >();
var outConnectors = new List <Tuple <NodeModel, int, int> >();
int i = 0;
if (outputs.Any())
{
foreach (var output in outputs)
{
if (outportList.All(x => !(x.Item1 == output.Item1 && x.Item2 == output.Item2)))
{
NodeModel outputSenderNode = output.Item1;
int outputSenderData = output.Item2;
NodeModel outputReceiverNode = output.Item3.Item2;
if (curriedNodeArgs.Any(x => x.OuterNode == outputReceiverNode))
{
continue;
}
outportList.Add(Tuple.Create(outputSenderNode, outputSenderData));
//Create Symbol Node
var node = new Output
{
Symbol = outputSenderNode.OutPortData[outputSenderData].NickName
};
//dynNodeView nodeUI = node.NodeUI;
var elNameAttrib =
node.GetType().GetCustomAttributes(typeof(NodeNameAttribute), false)[0] as
NodeNameAttribute;
if (elNameAttrib != null)
{
node.NickName = elNameAttrib.Name;
}
node.GUID = Guid.NewGuid();
//store the element in the elements list
newNodeWorkspace.Nodes.Add(node);
node.WorkSpace = newNodeWorkspace;
node.DisableReporting();
node.X = rightMost + 75 - leftShift;
node.Y = i * (50 + node.Height);
var conn = ConnectorModel.Make(
outputSenderNode,
node,
outputSenderData,
0,
PortType.INPUT);
if (conn != null)
{
newNodeWorkspace.Connectors.Add(conn);
}
i++;
}
}
//Connect outputs to new node
foreach (var output in outputs)
{
//Node to be connected to in CurrentWorkspace
NodeModel outputSenderNode = output.Item1;
//Port to be connected to on outPutNode_outer
int outputSenderData = output.Item2;
int outputReceiverData = output.Item3.Item1;
NodeModel outputReceiverNode = output.Item3.Item2;
var curriedNode = curriedNodeArgs.FirstOrDefault(x => x.OuterNode == outputReceiverNode);
if (curriedNode == null)
{
// we create the connectors in the current space later
//MVVM : replaced multiple dynNodeView refrences with dynNode
outConnectors.Add(
Tuple.Create(
outputReceiverNode,
outportList.FindIndex(
x => x.Item1 == outputSenderNode && x.Item2 == outputSenderData),
outputReceiverData));
}
else
{
int targetPort =
curriedNode.Inputs.First(x => x.InnerNodeInputSender == outputSenderNode)
.OuterNodeInPortData;
int targetPortIndex = curriedNode.OuterNodePortDataList.IndexOf(targetPort);
//Connect it (new dynConnector)
var conn = ConnectorModel.Make(
outputSenderNode,
curriedNode.InnerNode,
outputSenderData,
targetPortIndex + 1,
PortType.INPUT);
if (conn != null)
{
newNodeWorkspace.Connectors.Add(conn);
}
}
}
}
else
{
foreach (var hanging in
selectedNodeSet.SelectMany(
node =>
Enumerable.Range(0, node.OutPortData.Count)
.Where(port => !node.HasOutput(port))
.Select(port => new { node, port })).Distinct())
{
//Create Symbol Node
var node = new Output
{
Symbol = hanging.node.OutPortData[hanging.port].NickName
};
//dynNodeView nodeUI = node.NodeUI;
var elNameAttrib =
node.GetType().GetCustomAttributes(typeof(NodeNameAttribute), false)[0] as
NodeNameAttribute;
if (elNameAttrib != null)
{
node.NickName = elNameAttrib.Name;
}
node.GUID = Guid.NewGuid();
//store the element in the elements list
newNodeWorkspace.Nodes.Add(node);
node.WorkSpace = newNodeWorkspace;
node.DisableReporting();
node.X = rightMost + 75 - leftShift;
node.Y = i * (50 + node.Height);
var conn = ConnectorModel.Make(
hanging.node,
node,
hanging.port,
0,
PortType.INPUT);
if (conn != null)
{
newNodeWorkspace.Connectors.Add(conn);
}
i++;
}
}
#endregion
// save and load the definition from file
newNodeDefinition.SyncWithWorkspace(true, true);
dynSettings.Controller.DynamoModel.Workspaces.Add(newNodeWorkspace);
string name = newNodeDefinition.FunctionId.ToString();
var collapsedNode = dynSettings.Controller.DynamoModel.CreateNode(avgX, avgY, name);
undoRecorder.RecordCreationForUndo(collapsedNode);
// place the node as intended, not centered
collapsedNode.X = avgX;
collapsedNode.Y = avgY;
collapsedNode.DisableReporting();
foreach (var nodeTuple in inConnectors.Select((x, idx) => new { node = x.Item1, from = x.Item2, to = idx }))
{
var conn = ConnectorModel.Make(
nodeTuple.node,
collapsedNode,
nodeTuple.from,
nodeTuple.to,
PortType.INPUT);
if (conn != null)
{
currentWorkspace.Connectors.Add(conn);
undoRecorder.RecordCreationForUndo(conn);
}
}
foreach (var nodeTuple in outConnectors)
{
var conn = ConnectorModel.Make(
collapsedNode,
nodeTuple.Item1,
nodeTuple.Item2,
nodeTuple.Item3,
PortType.INPUT);
if (conn != null)
{
currentWorkspace.Connectors.Add(conn);
undoRecorder.RecordCreationForUndo(conn);
}
}
undoRecorder.EndActionGroup();
collapsedNode.EnableReporting();
currentWorkspace.EnableReporting();
foreach (var node in newNodeWorkspace.Nodes)
{
node.EnableReporting();
}
newNodeWorkspace.WatchChanges = true;
}
/// <summary>
/// Collapse a set of nodes in a given workspace.
/// </summary>
/// <param name="dynamoModel">The current DynamoModel</param>
/// <param name="selectedNodes"> The function definition for the user-defined node </param>
/// <param name="currentWorkspace"> The workspace where</param>
/// <param name="args"></param>
public static void Collapse(DynamoModel dynamoModel,
IEnumerable <NodeModel> selectedNodes,
WorkspaceModel currentWorkspace,
FunctionNamePromptEventArgs args = null)
{
if (args == null || !args.Success)
{
args = new FunctionNamePromptEventArgs();
dynamoModel.OnRequestsFunctionNamePrompt(null, args);
if (!args.Success)
{
return;
}
}
var selectedNodeSet = new HashSet <NodeModel>(selectedNodes);
// Note that undoable actions are only recorded for the "currentWorkspace",
// the nodes which get moved into "newNodeWorkspace" are not recorded for undo,
// even in the new workspace. Their creations will simply be treated as part of
// the opening of that new workspace (i.e. when a user opens a file, she will
// not expect the nodes that show up to be undoable).
//
// After local nodes are moved into "newNodeWorkspace" as the result of
// conversion, if user performs an undo, new set of nodes will be created in
// "currentWorkspace" (not moving those nodes in the "newNodeWorkspace" back
// into "currentWorkspace"). In another word, undo recording is on a per-
// workspace basis, it does not work across different workspaces.
//
UndoRedoRecorder undoRecorder = currentWorkspace.UndoRecorder;
using (undoRecorder.BeginActionGroup())
{
var newNodeWorkspace = new CustomNodeWorkspaceModel(
dynamoModel,
args.Name,
args.Category,
args.Description,
0,
0)
{
WatchChanges = false, HasUnsavedChanges = true
};
var newNodeDefinition = new CustomNodeDefinition(Guid.NewGuid())
{
WorkspaceModel = newNodeWorkspace
};
currentWorkspace.DisableReporting();
#region Determine Inputs and Outputs
//Step 1: determine which nodes will be inputs to the new node
var inputs =
new HashSet <Tuple <NodeModel, int, Tuple <int, NodeModel> > >(
selectedNodeSet.SelectMany(
node =>
Enumerable.Range(0, node.InPortData.Count)
.Where(node.HasConnectedInput)
.Select(data => Tuple.Create(node, data, node.Inputs[data]))
.Where(input => !selectedNodeSet.Contains(input.Item3.Item2))));
var outputs =
new HashSet <Tuple <NodeModel, int, Tuple <int, NodeModel> > >(
selectedNodeSet.SelectMany(
node =>
Enumerable.Range(0, node.OutPortData.Count)
.Where(node.HasOutput)
.SelectMany(
data =>
node.Outputs[data].Where(
output => !selectedNodeSet.Contains(output.Item2))
.Select(output => Tuple.Create(node, data, output)))));
#endregion
#region Detect 1-node holes (higher-order function extraction)
dynamoModel.Logger.LogWarning("Could not repair 1-node holes", WarningLevel.Mild);
// http://adsk-oss.myjetbrains.com/youtrack/issue/MAGN-5603
//var curriedNodeArgs =
// new HashSet<NodeModel>(
// inputs.Select(x => x.Item3.Item2)
// .Intersect(outputs.Select(x => x.Item3.Item2))).Select(
// outerNode =>
// {
// //var node = new Apply1();
// var node = newNodeWorkspace.AddNode<Apply1>();
// node.SetNickNameFromAttribute();
// node.DisableReporting();
// node.X = outerNode.X;
// node.Y = outerNode.Y;
// //Fetch all input ports
// // in order
// // that have inputs
// // and whose input comes from an inner node
// List<int> inPortsConnected =
// Enumerable.Range(0, outerNode.InPortData.Count)
// .Where(
// x =>
// outerNode.HasInput(x)
// && selectedNodeSet.Contains(
// outerNode.Inputs[x].Item2))
// .ToList();
// var nodeInputs =
// outputs.Where(output => output.Item3.Item2 == outerNode)
// .Select(
// output =>
// new
// {
// InnerNodeInputSender = output.Item1,
// OuterNodeInPortData = output.Item3.Item1
// })
// .ToList();
// nodeInputs.ForEach(_ => node.AddInput());
// node.RegisterAllPorts();
// return
// new
// {
// OuterNode = outerNode,
// InnerNode = node,
// Outputs =
// inputs.Where(
// input => input.Item3.Item2 == outerNode)
// .Select(input => input.Item3.Item1),
// Inputs = nodeInputs,
// OuterNodePortDataList = inPortsConnected
// };
// }).ToList();
#endregion
#region UI Positioning Calculations
double avgX = selectedNodeSet.Average(node => node.X);
double avgY = selectedNodeSet.Average(node => node.Y);
double leftMost = selectedNodeSet.Min(node => node.X);
double topMost = selectedNodeSet.Min(node => node.Y);
double rightMost = selectedNodeSet.Max(node => node.X + node.Width);
#endregion
#region Handle full selected connectors
// Step 2: Determine all the connectors whose start/end owners are
// both in the selection set, and then move them from the current
// workspace into the new workspace.
var fullySelectedConns =
new HashSet <ConnectorModel>(
currentWorkspace.Connectors.Where(
conn =>
{
bool startSelected = selectedNodeSet.Contains(conn.Start.Owner);
bool endSelected = selectedNodeSet.Contains(conn.End.Owner);
return(startSelected && endSelected);
}));
foreach (var ele in fullySelectedConns)
{
undoRecorder.RecordDeletionForUndo(ele);
currentWorkspace.Connectors.Remove(ele);
}
#endregion
#region Handle partially selected connectors
// Step 3: Partially selected connectors (either one of its start
// and end owners is in the selection) are to be destroyed.
var partiallySelectedConns =
currentWorkspace.Connectors.Where(
conn =>
selectedNodeSet.Contains(conn.Start.Owner) ||
selectedNodeSet.Contains(conn.End.Owner)).ToList();
foreach (ConnectorModel connector in partiallySelectedConns)
{
undoRecorder.RecordDeletionForUndo(connector);
connector.NotifyConnectedPortsOfDeletion();
currentWorkspace.Connectors.Remove(connector);
}
#endregion
#region Transfer nodes and connectors to new workspace
// Step 4: move all nodes to new workspace remove from old
// PB: This could be more efficiently handled by a copy paste, but we
// are preservering the node
foreach (var ele in selectedNodeSet)
{
undoRecorder.RecordDeletionForUndo(ele);
ele.SaveResult = false;
currentWorkspace.Nodes.Remove(ele);
// VisualizationManager and EngineController subscribe
// NodeDeleted event, so notify them that this node has
// been deleted.
dynamoModel.OnNodeDeleted(ele);
// Assign a new guid to this node, otherwise when node is
// compiled to AST, literally it is still in global scope
// instead of in function scope.
ele.GUID = Guid.NewGuid();
ele.RenderPackages.Clear();
ele.Workspace = newNodeWorkspace;
}
// add to new
newNodeWorkspace.Nodes.AddRange(selectedNodeSet);
newNodeWorkspace.Connectors.AddRange(fullySelectedConns);
foreach (var node in newNodeWorkspace.Nodes)
{
node.DisableReporting();
}
double leftShift = leftMost - 250;
foreach (NodeModel node in newNodeWorkspace.Nodes)
{
node.X = node.X - leftShift;
node.Y = node.Y - topMost;
}
#endregion
#region Process inputs
var inConnectors = new List <Tuple <NodeModel, int> >();
var uniqueInputSenders = new Dictionary <Tuple <NodeModel, int>, Symbol>();
//Step 3: insert variables (reference step 1)
foreach (var input in Enumerable.Range(0, inputs.Count).Zip(inputs, Tuple.Create))
{
int inputIndex = input.Item1;
NodeModel inputReceiverNode = input.Item2.Item1;
int inputReceiverData = input.Item2.Item2;
NodeModel inputNode = input.Item2.Item3.Item2;
int inputData = input.Item2.Item3.Item1;
Symbol node;
var key = Tuple.Create(inputNode, inputData);
if (uniqueInputSenders.ContainsKey(key))
{
node = uniqueInputSenders[key];
}
else
{
inConnectors.Add(Tuple.Create(inputNode, inputData));
node = newNodeWorkspace.AddNode <Symbol>();
node.InputSymbol = inputReceiverNode.InPortData[inputReceiverData].NickName;
node.SetNickNameFromAttribute();
node.DisableReporting();
node.X = 0;
node.Y = inputIndex * (50 + node.Height);
uniqueInputSenders[key] = node;
}
//var curriedNode = curriedNodeArgs.FirstOrDefault(x => x.OuterNode == inputNode);
//if (curriedNode == null)
//{
newNodeWorkspace.AddConnection(
node,
inputReceiverNode,
0,
inputReceiverData);
//}
//else
//{
// //Connect it to the applier
// newNodeWorkspace.AddConnection(node, curriedNode.InnerNode, 0, 0);
// //Connect applier to the inner input receive
// newNodeWorkspace.AddConnection(
// curriedNode.InnerNode,
// inputReceiverNode,
// 0,
// inputReceiverData);
//}
}
#endregion
#region Process outputs
//List of all inner nodes to connect an output. Unique.
var outportList = new List <Tuple <NodeModel, int> >();
var outConnectors = new List <Tuple <NodeModel, int, int> >();
int i = 0;
if (outputs.Any())
{
foreach (var output in outputs)
{
if (
outportList.All(
x => !(x.Item1 == output.Item1 && x.Item2 == output.Item2)))
{
NodeModel outputSenderNode = output.Item1;
int outputSenderData = output.Item2;
NodeModel outputReceiverNode = output.Item3.Item2;
//if (curriedNodeArgs.Any(x => x.OuterNode == outputReceiverNode))
// continue;
outportList.Add(Tuple.Create(outputSenderNode, outputSenderData));
//Create Symbol Node
var node = newNodeWorkspace.AddNode <Output>();
node.Symbol = outputSenderNode.OutPortData[outputSenderData].NickName;
node.SetNickNameFromAttribute();
node.DisableReporting();
node.X = rightMost + 75 - leftShift;
node.Y = i * (50 + node.Height);
newNodeWorkspace.AddConnection(
outputSenderNode,
node,
outputSenderData,
0);
i++;
}
}
//Connect outputs to new node
foreach (var output in outputs)
{
//Node to be connected to in CurrentWorkspace
NodeModel outputSenderNode = output.Item1;
//Port to be connected to on outPutNode_outer
int outputSenderData = output.Item2;
int outputReceiverData = output.Item3.Item1;
NodeModel outputReceiverNode = output.Item3.Item2;
//var curriedNode =
// curriedNodeArgs.FirstOrDefault(x => x.OuterNode == outputReceiverNode);
//if (curriedNode == null)
//{
// we create the connectors in the current space later
outConnectors.Add(
Tuple.Create(
outputReceiverNode,
outportList.FindIndex(
x =>
x.Item1 == outputSenderNode &&
x.Item2 == outputSenderData),
outputReceiverData));
//}
//else
//{
// int targetPort =
// curriedNode.Inputs.First(
// x => x.InnerNodeInputSender == outputSenderNode)
// .OuterNodeInPortData;
// int targetPortIndex =
// curriedNode.OuterNodePortDataList.IndexOf(targetPort);
// //Connect it (new dynConnector)
// newNodeWorkspace.AddConnection(
// outputSenderNode,
// curriedNode.InnerNode,
// outputSenderData,
// targetPortIndex + 1);
//}
}
}
else
{
foreach (var hanging in
selectedNodeSet.SelectMany(
node =>
Enumerable.Range(0, node.OutPortData.Count)
.Where(port => !node.HasOutput(port))
.Select(port => new { node, port })).Distinct())
{
//Create Symbol Node
var node = newNodeWorkspace.AddNode <Output>();
node.Symbol = hanging.node.OutPortData[hanging.port].NickName;
node.SetNickNameFromAttribute();
//store the element in the elements list
node.DisableReporting();
node.X = rightMost + 75 - leftShift;
node.Y = i * (50 + node.Height);
newNodeWorkspace.AddConnection(hanging.node, node, hanging.port, 0);
i++;
}
}
#endregion
// save and load the definition from file
newNodeDefinition.SyncWithWorkspace(dynamoModel, true, true);
dynamoModel.Workspaces.Add(newNodeWorkspace);
string name = newNodeDefinition.FunctionId.ToString();
var collapsedNode = currentWorkspace.AddNode(avgX, avgY, name);
undoRecorder.RecordCreationForUndo(collapsedNode);
// place the node as intended, not centered
collapsedNode.X = avgX;
collapsedNode.Y = avgY;
collapsedNode.DisableReporting();
foreach (
var nodeTuple in
inConnectors.Select(
(x, idx) => new { node = x.Item1, from = x.Item2, to = idx }))
{
var conn = currentWorkspace.AddConnection(
nodeTuple.node,
collapsedNode,
nodeTuple.from,
nodeTuple.to);
if (conn != null)
{
undoRecorder.RecordCreationForUndo(conn);
}
}
foreach (var nodeTuple in outConnectors)
{
var conn = currentWorkspace.AddConnection(
collapsedNode,
nodeTuple.Item1,
nodeTuple.Item2,
nodeTuple.Item3);
if (conn != null)
{
undoRecorder.RecordCreationForUndo(conn);
}
}
collapsedNode.EnableReporting();
currentWorkspace.EnableReporting();
foreach (var node in newNodeWorkspace.Nodes)
{
node.EnableReporting();
}
newNodeWorkspace.WatchChanges = true;
}
}
/// <summary>
/// Collapse a set of nodes in a given workspace.
/// </summary>
/// <param name="selectedNodes"> The function definition for the user-defined node </param>
/// <param name="currentWorkspace"> The workspace where</param>
/// <param name="isTestMode"></param>
/// <param name="args"></param>
public WorkspaceModel Collapse(
IEnumerable <NodeModel> selectedNodes, WorkspaceModel currentWorkspace,
bool isTestMode, FunctionNamePromptEventArgs args)
{
var selectedNodeSet = new HashSet <NodeModel>(selectedNodes);
// Note that undoable actions are only recorded for the "currentWorkspace",
// the nodes which get moved into "newNodeWorkspace" are not recorded for undo,
// even in the new workspace. Their creations will simply be treated as part of
// the opening of that new workspace (i.e. when a user opens a file, she will
// not expect the nodes that show up to be undoable).
//
// After local nodes are moved into "newNodeWorkspace" as the result of
// conversion, if user performs an undo, new set of nodes will be created in
// "currentWorkspace" (not moving those nodes in the "newNodeWorkspace" back
// into "currentWorkspace"). In another word, undo recording is on a per-
// workspace basis, it does not work across different workspaces.
//
UndoRedoRecorder undoRecorder = currentWorkspace.UndoRecorder;
CustomNodeWorkspaceModel newWorkspace;
using (undoRecorder.BeginActionGroup())
{
#region Determine Inputs and Outputs
//Step 1: determine which nodes will be inputs to the new node
var inputs =
new HashSet <Tuple <NodeModel, int, Tuple <int, NodeModel> > >(
selectedNodeSet.SelectMany(
node =>
Enumerable.Range(0, node.InPortData.Count)
.Where(node.HasConnectedInput)
.Select(data => Tuple.Create(node, data, node.Inputs[data]))
.Where(input => !selectedNodeSet.Contains(input.Item3.Item2))));
var outputs =
new HashSet <Tuple <NodeModel, int, Tuple <int, NodeModel> > >(
selectedNodeSet.SelectMany(
node =>
Enumerable.Range(0, node.OutPortData.Count)
.Where(node.HasOutput)
.SelectMany(
data =>
node.Outputs[data].Where(
output => !selectedNodeSet.Contains(output.Item2))
.Select(output => Tuple.Create(node, data, output)))));
#endregion
#region Detect 1-node holes (higher-order function extraction)
Log("Could not repair 1-node holes", WarningLevel.Mild);
// http://adsk-oss.myjetbrains.com/youtrack/issue/MAGN-5603
//var curriedNodeArgs =
// new HashSet<NodeModel>(
// inputs.Select(x => x.Item3.Item2)
// .Intersect(outputs.Select(x => x.Item3.Item2))).Select(
// outerNode =>
// {
// //var node = new Apply1();
// var node = newNodeWorkspace.AddNode<Apply1>();
// node.SetNickNameFromAttribute();
// node.DisableReporting();
// node.X = outerNode.X;
// node.Y = outerNode.Y;
// //Fetch all input ports
// // in order
// // that have inputs
// // and whose input comes from an inner node
// List<int> inPortsConnected =
// Enumerable.Range(0, outerNode.InPortData.Count)
// .Where(
// x =>
// outerNode.HasInput(x)
// && selectedNodeSet.Contains(
// outerNode.Inputs[x].Item2))
// .ToList();
// var nodeInputs =
// outputs.Where(output => output.Item3.Item2 == outerNode)
// .Select(
// output =>
// new
// {
// InnerNodeInputSender = output.Item1,
// OuterNodeInPortData = output.Item3.Item1
// })
// .ToList();
// nodeInputs.ForEach(_ => node.AddInput());
// node.RegisterAllPorts();
// return
// new
// {
// OuterNode = outerNode,
// InnerNode = node,
// Outputs =
// inputs.Where(
// input => input.Item3.Item2 == outerNode)
// .Select(input => input.Item3.Item1),
// Inputs = nodeInputs,
// OuterNodePortDataList = inPortsConnected
// };
// }).ToList();
#endregion
#region UI Positioning Calculations
double avgX = selectedNodeSet.Average(node => node.X);
double avgY = selectedNodeSet.Average(node => node.Y);
double leftMost = selectedNodeSet.Min(node => node.X);
double topMost = selectedNodeSet.Min(node => node.Y);
double rightMost = selectedNodeSet.Max(node => node.X + node.Width);
double leftShift = leftMost - 250;
#endregion
#region Handle full selected connectors
// Step 2: Determine all the connectors whose start/end owners are
// both in the selection set, and then move them from the current
// workspace into the new workspace.
var fullySelectedConns = new HashSet <ConnectorModel>(
currentWorkspace.Connectors.Where(
conn =>
{
bool startSelected = selectedNodeSet.Contains(conn.Start.Owner);
bool endSelected = selectedNodeSet.Contains(conn.End.Owner);
return(startSelected && endSelected);
}));
foreach (var connector in fullySelectedConns)
{
undoRecorder.RecordDeletionForUndo(connector);
connector.Delete();
}
#endregion
#region Handle partially selected connectors
// Step 3: Partially selected connectors (either one of its start
// and end owners is in the selection) are to be destroyed.
var partiallySelectedConns =
currentWorkspace.Connectors.Where(
conn =>
selectedNodeSet.Contains(conn.Start.Owner) ||
selectedNodeSet.Contains(conn.End.Owner)).ToList();
foreach (var connector in partiallySelectedConns)
{
undoRecorder.RecordDeletionForUndo(connector);
connector.Delete();
}
#endregion
#region Transfer nodes and connectors to new workspace
var newNodes = new List <NodeModel>();
// Step 4: move all nodes to new workspace remove from old
// PB: This could be more efficiently handled by a copy paste, but we
// are preservering the node
foreach (var node in selectedNodeSet)
{
undoRecorder.RecordDeletionForUndo(node);
currentWorkspace.RemoveNode(node);
// Assign a new guid to this node, otherwise when node is
// compiled to AST, literally it is still in global scope
// instead of in function scope.
node.GUID = Guid.NewGuid();
node.RenderPackages.Clear();
// shit nodes
node.X = node.X - leftShift;
node.Y = node.Y - topMost;
newNodes.Add(node);
}
foreach (var conn in fullySelectedConns)
{
ConnectorModel.Make(conn.Start.Owner, conn.End.Owner, conn.Start.Index, conn.End.Index);
}
#endregion
#region Process inputs
var inConnectors = new List <Tuple <NodeModel, int> >();
var uniqueInputSenders = new Dictionary <Tuple <NodeModel, int>, Symbol>();
//Step 3: insert variables (reference step 1)
foreach (var input in Enumerable.Range(0, inputs.Count).Zip(inputs, Tuple.Create))
{
int inputIndex = input.Item1;
NodeModel inputReceiverNode = input.Item2.Item1;
int inputReceiverData = input.Item2.Item2;
NodeModel inputNode = input.Item2.Item3.Item2;
int inputData = input.Item2.Item3.Item1;
Symbol node;
var key = Tuple.Create(inputNode, inputData);
if (uniqueInputSenders.ContainsKey(key))
{
node = uniqueInputSenders[key];
}
else
{
inConnectors.Add(Tuple.Create(inputNode, inputData));
node = new Symbol
{
InputSymbol = inputReceiverNode.InPortData[inputReceiverData].NickName,
X = 0
};
node.SetNickNameFromAttribute();
node.Y = inputIndex * (50 + node.Height);
uniqueInputSenders[key] = node;
newNodes.Add(node);
}
//var curriedNode = curriedNodeArgs.FirstOrDefault(x => x.OuterNode == inputNode);
//if (curriedNode == null)
//{
ConnectorModel.Make(node, inputReceiverNode, 0, inputReceiverData);
//}
//else
//{
// //Connect it to the applier
// newNodeWorkspace.AddConnection(node, curriedNode.InnerNode, 0, 0);
// //Connect applier to the inner input receive
// newNodeWorkspace.AddConnection(
// curriedNode.InnerNode,
// inputReceiverNode,
// 0,
// inputReceiverData);
//}
}
#endregion
#region Process outputs
//List of all inner nodes to connect an output. Unique.
var outportList = new List <Tuple <NodeModel, int> >();
var outConnectors = new List <Tuple <NodeModel, int, int> >();
int i = 0;
if (outputs.Any())
{
foreach (var output in outputs)
{
if (outportList.All(x => !(x.Item1 == output.Item1 && x.Item2 == output.Item2)))
{
NodeModel outputSenderNode = output.Item1;
int outputSenderData = output.Item2;
//NodeModel outputReceiverNode = output.Item3.Item2;
//if (curriedNodeArgs.Any(x => x.OuterNode == outputReceiverNode))
// continue;
outportList.Add(Tuple.Create(outputSenderNode, outputSenderData));
//Create Symbol Node
var node = new Output
{
Symbol = outputSenderNode.OutPortData[outputSenderData].NickName,
X = rightMost + 75 - leftShift
};
node.Y = i * (50 + node.Height);
node.SetNickNameFromAttribute();
newNodes.Add(node);
ConnectorModel.Make(outputSenderNode, node, outputSenderData, 0);
i++;
}
}
//Connect outputs to new node
outConnectors.AddRange(
from output in outputs
let outputSenderNode = output.Item1
let outputSenderData = output.Item2
let outputReceiverData = output.Item3.Item1
let outputReceiverNode = output.Item3.Item2
select
Tuple.Create(
outputReceiverNode,
outportList.FindIndex(
x => x.Item1 == outputSenderNode && x.Item2 == outputSenderData),
outputReceiverData));
}
else
{
foreach (var hanging in
selectedNodeSet.SelectMany(
node =>
Enumerable.Range(0, node.OutPortData.Count)
.Where(port => !node.HasOutput(port))
.Select(port => new { node, port })).Distinct())
{
//Create Symbol Node
var node = new Output
{
Symbol = hanging.node.OutPortData[hanging.port].NickName,
X = rightMost + 75 - leftShift
};
node.Y = i * (50 + node.Height);
node.SetNickNameFromAttribute();
newNodes.Add(node);
ConnectorModel.Make(hanging.node, node, hanging.port, 0);
i++;
}
}
#endregion
var newId = Guid.NewGuid();
newWorkspace = new CustomNodeWorkspaceModel(
args.Name,
args.Category,
args.Description,
nodeFactory,
newNodes,
Enumerable.Empty <NoteModel>(),
0,
0,
newId);
RegisterCustomNodeWorkspace(newWorkspace);
var collapsedNode = CreateCustomNodeInstance(newId, isTestMode: isTestMode);
collapsedNode.X = avgX;
collapsedNode.Y = avgY;
currentWorkspace.AddNode(collapsedNode, centered: false);
undoRecorder.RecordCreationForUndo(collapsedNode);
foreach (var connector in
inConnectors.Select((x, idx) => new { node = x.Item1, from = x.Item2, to = idx })
.Select(
nodeTuple =>
ConnectorModel.Make(
nodeTuple.node,
collapsedNode,
nodeTuple.@from,
nodeTuple.to))
.Where(connector => connector != null))
{
undoRecorder.RecordCreationForUndo(connector);
}
foreach (var connector in
outConnectors.Select(
nodeTuple =>
ConnectorModel.Make(
collapsedNode,
nodeTuple.Item1,
nodeTuple.Item2,
nodeTuple.Item3)).Where(connector => connector != null))
{
undoRecorder.RecordCreationForUndo(connector);
}
}
return(newWorkspace);
}