/// <summary>
/// Deserialize a function definition from a given path. A side effect of this function is that
/// the node is added to the dictionary of loadedNodes.
/// </summary>
/// <param name="funcDefGuid">The function guid we're currently loading</param>
/// <param name="controller">Reference to the calling controller</param>
/// <param name="def">The resultant function definition</param>
/// <returns></returns>
private bool GetDefinitionFromPath(Guid funcDefGuid, DynamoController controller, out FunctionDefinition def)
{
try
{
var xmlPath = GetNodePath(funcDefGuid);
#region read xml file
var xmlDoc = new XmlDocument();
xmlDoc.Load(xmlPath);
string funName = null;
string category = "";
double cx = dynBench.CANVAS_OFFSET_X;
double cy = dynBench.CANVAS_OFFSET_Y;
string id = "";
// load the header
foreach (XmlNode node in xmlDoc.GetElementsByTagName("dynWorkspace"))
{
foreach (XmlAttribute att in node.Attributes)
{
if (att.Name.Equals("X"))
cx = Convert.ToDouble(att.Value);
else if (att.Name.Equals("Y"))
cy = Convert.ToDouble(att.Value);
else if (att.Name.Equals("Name"))
funName = att.Value;
else if (att.Name.Equals("Category"))
category = att.Value;
else if (att.Name.Equals("ID"))
{
id = att.Value;
}
}
}
// we have a dyf and it lacks an ID field, we need to assign it
// a deterministic guid based on its name. By doing it deterministically,
// files remain compatible
if (string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(funName))
{
id = GuidUtility.Create(GuidUtility.UrlNamespace, funName).ToString();
}
#endregion
//If there is no function name, then we are opening a home definition
if (funName == null)
{
//View the home workspace, then open the bench file
if (!controller.ViewingHomespace)
controller.ViewHomeWorkspace(); //TODO: Refactor
def = null;
return controller.OpenWorkbench(xmlPath);
}
dynSettings.Bench.Log("Loading node definition for \"" + funName + "\" from: " + xmlPath);
var workSpace = new FuncWorkspace(
funName, category.Length > 0
? category
: BuiltinNodeCategories.MISC, cx, cy);
def = new FunctionDefinition(Guid.Parse(id))
{
Workspace = workSpace
};
// load a dummy version, so any nodes depending on this node
// will find an (empty) identifier on compilation
FScheme.Expression dummyExpression = FScheme.Expression.NewNumber_E(5);
controller.FSchemeEnvironment.DefineSymbol(def.FunctionId.ToString(), dummyExpression);
this.loadedNodes.Add(def.FunctionId, def);
dynWorkspace ws = def.Workspace;
//this.Log("Opening definition " + xmlPath + "...");
XmlNodeList elNodes = xmlDoc.GetElementsByTagName("dynElements");
XmlNodeList cNodes = xmlDoc.GetElementsByTagName("dynConnectors");
XmlNodeList nNodes = xmlDoc.GetElementsByTagName("dynNotes");
XmlNode elNodesList = elNodes[0];
XmlNode cNodesList = cNodes[0];
XmlNode nNodesList = nNodes[0];
#region instantiate nodes
foreach (XmlNode elNode in elNodesList.ChildNodes)
{
XmlAttribute typeAttrib = elNode.Attributes[0];
XmlAttribute guidAttrib = elNode.Attributes[1];
XmlAttribute nicknameAttrib = elNode.Attributes[2];
XmlAttribute xAttrib = elNode.Attributes[3];
XmlAttribute yAttrib = elNode.Attributes[4];
string typeName = typeAttrib.Value;
string oldNamespace = "Dynamo.Elements.";
if (typeName.StartsWith(oldNamespace))
typeName = "Dynamo.Nodes." + typeName.Remove(0, oldNamespace.Length);
//test the GUID to confirm that it is non-zero
//if it is zero, then we have to fix it
//this will break the connectors, but it won't keep
//propagating bad GUIDs
var guid = new Guid(guidAttrib.Value);
if (guid == Guid.Empty)
{
guid = Guid.NewGuid();
}
string nickname = nicknameAttrib.Value;
double x = Convert.ToDouble(xAttrib.Value);
double y = Convert.ToDouble(yAttrib.Value);
//Type t = Type.GetType(typeName);
TypeLoadData tData;
Type t;
if (!controller.builtinTypesByTypeName.TryGetValue(typeName, out tData))
{
t = Type.GetType(typeName);
if (t == null)
{
dynSettings.Bench.Log("Error loading definition. Could not load node of type: " + typeName);
return false;
}
}
else
t = tData.Type;
var el = controller.CreateInstanceAndAddNodeToWorkspace(t, nickname, guid, x, y, ws, Visibility.Hidden);
if (el == null)
return false;
el.DisableReporting();
el.LoadElement(elNode); // inject the node properties from the xml
// it has no
if (el is dynFunction)
{
var fun = el as dynFunction;
// we've found a custom node, we need to attempt to load its guid.
// if it doesn't exist (i.e. its a legacy node), we need to assign it one,
// deterministically
Guid funId;
try
{
funId = Guid.Parse(fun.Symbol);
}
catch
{
funId = GuidUtility.Create(GuidUtility.UrlNamespace, nicknameAttrib.Value);
fun.Symbol = funId.ToString();
}
// if it's not a recurisve node and it's not yet loaded, load it
if (funcDefGuid != funId && !this.loadedNodes.ContainsKey(funId))
{
dynSettings.Controller.CustomNodeLoader.GetFunctionDefinition(funId);
fun.Definition = this.loadedNodes[funId];
}
else if ( this.loadedNodes.ContainsKey(funId ))
{
fun.Definition = this.loadedNodes[funId];
}
}
}
#endregion
dynSettings.Bench.WorkBench.UpdateLayout();
#region instantiate connectors
foreach (XmlNode connector in cNodesList.ChildNodes)
{
XmlAttribute guidStartAttrib = connector.Attributes[0];
XmlAttribute intStartAttrib = connector.Attributes[1];
XmlAttribute guidEndAttrib = connector.Attributes[2];
XmlAttribute intEndAttrib = connector.Attributes[3];
XmlAttribute portTypeAttrib = connector.Attributes[4];
var guidStart = new Guid(guidStartAttrib.Value);
var guidEnd = new Guid(guidEndAttrib.Value);
int startIndex = Convert.ToInt16(intStartAttrib.Value);
int endIndex = Convert.ToInt16(intEndAttrib.Value);
int portType = Convert.ToInt16(portTypeAttrib.Value);
//find the elements to connect
dynNode start = null;
dynNode end = null;
foreach (dynNode e in ws.Nodes)
{
if (e.NodeUI.GUID == guidStart)
{
start = e;
}
else if (e.NodeUI.GUID == guidEnd)
{
end = e;
}
if (start != null && end != null)
{
break;
}
}
//don't connect if the end element is an instance map
//those have a morphing set of inputs
//dynInstanceParameterMap endTest = end as dynInstanceParameterMap;
//if (endTest != null)
//{
// continue;
//}
try
{
if (start != null && end != null && start != end)
{
var newConnector = new dynConnector(
start.NodeUI, end.NodeUI,
startIndex, endIndex,
portType, false
);
ws.Connectors.Add(newConnector);
}
}
catch
{
dynSettings.Bench.Log(string.Format("ERROR : Could not create connector between {0} and {1}.", start.NodeUI.GUID, end.NodeUI.GUID));
}
}
#endregion
#region instantiate notes
if (nNodesList != null)
{
foreach (XmlNode note in nNodesList.ChildNodes)
{
XmlAttribute textAttrib = note.Attributes[0];
XmlAttribute xAttrib = note.Attributes[1];
XmlAttribute yAttrib = note.Attributes[2];
string text = textAttrib.Value;
double x = Convert.ToDouble(xAttrib.Value);
double y = Convert.ToDouble(yAttrib.Value);
//dynNote n = Bench.AddNote(text, x, y, ws);
//Bench.AddNote(text, x, y, ws);
var paramDict = new Dictionary<string, object>();
paramDict.Add("x", x);
paramDict.Add("y", y);
paramDict.Add("text", text);
paramDict.Add("workspace", ws);
DynamoCommands.AddNoteCmd.Execute(paramDict);
}
}
#endregion
foreach (dynNode e in ws.Nodes)
e.EnableReporting();
DynamoController.hideWorkspace(ws);
ws.FilePath = xmlPath;
controller.PackageManagerClient.LoadPackageHeader(def, funName);
var expression = CompileFunction(def);
controller.FSchemeEnvironment.DefineSymbol(def.FunctionId.ToString(), expression);
}
catch (Exception ex)
{
dynSettings.Bench.Log("There was an error opening the workbench.");
dynSettings.Bench.Log(ex);
controller.CleanWorkbench();
def = null;
return false;
}
return true;
}
/// <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>
internal static void Collapse(IEnumerable<dynNodeModel> selectedNodes, dynWorkspaceModel currentWorkspace)
{
var selectedNodeSet = new HashSet<dynNodeModel>(selectedNodes);
//First, prompt the user to enter a name
string newNodeName ="", newNodeCategory ="";
if (!dynSettings.Controller.DynamoViewModel.ShowNewFunctionDialog(ref newNodeName, ref newNodeCategory))
{
return;
}
var newNodeWorkspace = new FuncWorkspace(newNodeName, newNodeCategory, 0, 0)
{
WatchChanges = false
};
var newNodeDefinition = new FunctionDefinition(Guid.NewGuid())
{
Workspace = 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<dynNodeModel, int, Tuple<int, dynNodeModel>>>(
selectedNodeSet.SelectMany(
node => Enumerable.Range(0, node.InPortData.Count).Where(node.HasInput)
.Select(data => Tuple.Create(node, data, node.Inputs[data]))
.Where(input => !selectedNodeSet.Contains(input.Item3.Item2))));
var outputs = new HashSet<Tuple<dynNodeModel, int, Tuple<int, dynNodeModel>>>(
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<dynNodeModel>(
inputs
.Select(x => x.Item3.Item2)
.Intersect(outputs.Select(x => x.Item3.Item2)))
.Select(
outerNode =>
{
var node = new dynApply1();
//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();
//MVVM: don't call update layout here
//dynSettings.Bench.WorkBench.UpdateLayout();
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 Move selection to new workspace
var connectors = new HashSet<dynConnectorModel>(currentWorkspace.Connectors.Where(
conn => selectedNodeSet.Contains(conn.Start.Owner)
&& selectedNodeSet.Contains(conn.End.Owner)));
//Step 2: move all nodes to new workspace
// remove from old
foreach (var ele in selectedNodeSet)
{
currentWorkspace.Nodes.Remove(ele);
}
foreach (var ele in connectors)
{
currentWorkspace.Connectors.Remove(ele);
}
// add to new
newNodeWorkspace.Nodes.AddRange(selectedNodeSet);
newNodeWorkspace.Connectors.AddRange(connectors);
double leftShift = leftMost - 250;
foreach (dynNodeModel node in newNodeWorkspace.Nodes)
{
node.X = node.X - leftShift;
node.Y = node.Y - topMost;
}
#endregion
#region Insert new node into the current workspace
//Step 5: insert new node into original workspace
var collapsedNode = dynSettings.Controller.DynamoViewModel.CreateFunction(
inputs.Select(x => x.Item1.InPortData[x.Item2].NickName),
outputs
.Where(x => !curriedNodeArgs.Any(y => y.OuterNode == x.Item3.Item2))
.Select(x => x.Item1.OutPortData[x.Item2].NickName),
newNodeDefinition);
collapsedNode.GUID = Guid.NewGuid();
currentWorkspace.Nodes.Add(collapsedNode);
collapsedNode.WorkSpace = currentWorkspace;
collapsedNode.X = avgX;
collapsedNode.Y = avgY;
#endregion
#region Destroy all hanging connectors
//Step 6: connect inputs and outputs
var removeConnectors = currentWorkspace.Connectors.Where(c =>
selectedNodeSet.Contains(c.Start.Owner) ||
selectedNodeSet.Contains(c.End.Owner))
.ToList();
foreach (dynConnectorModel connector in removeConnectors)
{
connector.NotifyConnectedPortsOfDeletion();
currentWorkspace.Connectors.Remove(connector);
}
#endregion
newNodeWorkspace.Nodes.ToList().ForEach(x => x.DisableReporting());
var inConnectors = new List<Tuple<dynNodeModel, int, int>>();
#region Process inputs
var uniqueInputSenders = new Dictionary<Tuple<dynNodeModel, int>, dynSymbol>();
//Step 3: insert variables (reference step 1)
foreach (var input in Enumerable.Range(0, inputs.Count).Zip(inputs, Tuple.Create))
{
int inputIndex = input.Item1;
dynNodeModel inputReceiverNode = input.Item2.Item1;
int inputReceiverData = input.Item2.Item2;
dynNodeModel inputNode = input.Item2.Item3.Item2;
int inputData = input.Item2.Item3.Item1;
dynSymbol 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, inputIndex));
//Create Symbol Node
node = new dynSymbol
{
Symbol = 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();
//MVVM : Do not add view directly to canvas
/*dynSettings.Bench.WorkBench.Children.Add(nodeUI);
//Place it in an appropriate spot
Canvas.SetLeft(nodeUI, 0);
Canvas.SetTop(nodeUI, inputIndex * (50 + node.NodeUI.Height));
dynSettings.Bench.WorkBench.UpdateLayout();*/
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 = dynConnectorModel.Make(node,
inputReceiverNode,
0,
inputReceiverData,
0 );
if (conn1 != null)
newNodeWorkspace.Connectors.Add(conn1);
}
else
{
//Connect it to the applier
var conn = dynConnectorModel.Make(node,
curriedNode.InnerNode,
0,
0,
0);
if (conn != null)
newNodeWorkspace.Connectors.Add(conn);
//Connect applier to the inner input receive
var conn2 = dynConnectorModel.Make(
curriedNode.InnerNode,
inputReceiverNode,
0,
inputReceiverData,
0);
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<dynNodeModel, int>>();
var outConnectors = new List<Tuple<dynNodeModel, int, int>>();
int i = 0;
foreach (var output in outputs)
{
if (outportList.All(x => !(x.Item1 == output.Item1 && x.Item2 == output.Item2)))
{
dynNodeModel outputSenderNode = output.Item1;
int outputSenderData = output.Item2;
dynNodeModel outputReceiverNode = output.Item3.Item2;
if (curriedNodeArgs.Any(x => x.OuterNode == outputReceiverNode))
continue;
outportList.Add(Tuple.Create(outputSenderNode, outputSenderData));
//Create Symbol Node
var node = new dynOutput
{
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();
//MVVM : Do not add view directly to canvas
/*dynSettings.Bench.WorkBench.Children.Add(nodeUI);
//Place it in an appropriate spot
Canvas.SetLeft(nodeUI, rightMost + 75 - leftShift);
Canvas.SetTop(nodeUI, i * (50 + node.NodeUI.Height));
dynSettings.Bench.WorkBench.UpdateLayout();*/
node.X = rightMost + 75 - leftShift;
node.Y = i*(50 + node.Height);
var conn = dynConnectorModel.Make(
outputSenderNode,
node,
outputSenderData,
0,
0 );
if (conn != null)
newNodeWorkspace.Connectors.Add(conn);
i++;
}
}
//Connect outputs to new node
foreach (var output in outputs)
{
//Node to be connected to in CurrentSpace
dynNodeModel outputSenderNode = output.Item1;
//Port to be connected to on outPutNode_outer
int outputSenderData = output.Item2;
int outputReceiverData = output.Item3.Item1;
dynNodeModel 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 = dynConnectorModel.Make(
outputSenderNode,
curriedNode.InnerNode,
outputSenderData,
targetPortIndex + 1,
0);
if (conn != null)
newNodeWorkspace.Connectors.Add(conn);
}
}
#endregion
//set the name on the node
collapsedNode.NickName = newNodeName;
currentWorkspace.Nodes.Remove(collapsedNode);
// save and load the definition from file
dynSettings.Controller.CustomNodeLoader.SetNodeInfo(newNodeName, newNodeCategory, newNodeDefinition.FunctionId, "");
var path = dynSettings.Controller.DynamoViewModel.SaveFunctionOnly(newNodeDefinition);
dynSettings.Controller.CustomNodeLoader.SetNodePath(newNodeDefinition.FunctionId, path);
dynSettings.Controller.SearchViewModel.Add(newNodeName, newNodeCategory, newNodeDefinition.FunctionId);
dynSettings.Controller.DynamoViewModel.CreateNodeCommand.Execute(new Dictionary<string, object>()
{
{"name", collapsedNode.Definition.FunctionId.ToString() },
{"x", avgX },
{"y", avgY }
});
var newlyPlacedCollapsedNode = currentWorkspace.Nodes
.Where(node => node is dynFunction)
.First(node => ((dynFunction)node).Definition.FunctionId == newNodeDefinition.FunctionId);
// place the node as intended, not centered
newlyPlacedCollapsedNode.X = avgX;
newlyPlacedCollapsedNode.Y = avgY;
newlyPlacedCollapsedNode.DisableReporting();
foreach (var nodeTuple in inConnectors)
{
var conn = dynConnectorModel.Make(
nodeTuple.Item1,
newlyPlacedCollapsedNode,
nodeTuple.Item2,
nodeTuple.Item3,
0 );
if (conn != null)
currentWorkspace.Connectors.Add(conn);
}
foreach (var nodeTuple in outConnectors)
{
var conn = dynConnectorModel.Make(
newlyPlacedCollapsedNode,
nodeTuple.Item1,
nodeTuple.Item2,
nodeTuple.Item3,
0 );
if (conn != null)
currentWorkspace.Connectors.Add(conn);
}
newlyPlacedCollapsedNode.EnableReporting();
currentWorkspace.EnableReporting();
newNodeWorkspace.WatchChanges = true;
}
/// <summary>
/// Deserialize a function definition from a given path. A side effect of this function is that
/// the node is added to the dictionary of loadedNodes.
/// </summary>
/// <param name="funcDefGuid">The function guid we're currently loading</param>
/// <param name="controller">Reference to the calling controller</param>
/// <param name="def">The resultant function definition</param>
/// <returns></returns>
private bool GetDefinitionFromPath(Guid funcDefGuid, DynamoController controller, out FunctionDefinition def)
{
try
{
var xmlPath = GetNodePath(funcDefGuid);
#region read xml file
var xmlDoc = new XmlDocument();
xmlDoc.Load(xmlPath);
string funName = null;
string category = "";
double cx = DynamoView.CANVAS_OFFSET_X;
double cy = DynamoView.CANVAS_OFFSET_Y;
string id = "";
// load the header
foreach (XmlNode node in xmlDoc.GetElementsByTagName("dynWorkspace"))
{
foreach (XmlAttribute att in node.Attributes)
{
if (att.Name.Equals("X"))
cx = Convert.ToDouble(att.Value);
else if (att.Name.Equals("Y"))
cy = Convert.ToDouble(att.Value);
else if (att.Name.Equals("Name"))
funName = att.Value;
else if (att.Name.Equals("Category"))
category = att.Value;
else if (att.Name.Equals("ID"))
{
id = att.Value;
}
}
}
// we have a dyf and it lacks an ID field, we need to assign it
// a deterministic guid based on its name. By doing it deterministically,
// files remain compatible
if (string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(funName))
{
id = GuidUtility.Create(GuidUtility.UrlNamespace, funName).ToString();
}
#endregion
DynamoCommands.WriteToLogCmd.Execute("Loading node definition for \"" + funName + "\" from: " + xmlPath);
var workSpace = new FuncWorkspace(
funName, category.Length > 0
? category
: BuiltinNodeCategories.SCRIPTING_CUSTOMNODES, cx, cy);
def = new FunctionDefinition(Guid.Parse(id))
{
Workspace = workSpace
};
// load a dummy version, so any nodes depending on this node
// will find an (empty) identifier on compilation
FScheme.Expression dummyExpression = FScheme.Expression.NewNumber_E(0);
controller.FSchemeEnvironment.DefineSymbol(def.FunctionId.ToString(), dummyExpression);
this.loadedNodes.Add(def.FunctionId, def);
dynWorkspaceModel ws = def.Workspace;
XmlNodeList elNodes = xmlDoc.GetElementsByTagName("dynElements");
XmlNodeList cNodes = xmlDoc.GetElementsByTagName("dynConnectors");
XmlNodeList nNodes = xmlDoc.GetElementsByTagName("dynNotes");
XmlNode elNodesList = elNodes[0];
XmlNode cNodesList = cNodes[0];
XmlNode nNodesList = nNodes[0];
#region instantiate nodes
List<Guid> badNodes = new List<Guid>();
foreach (XmlNode elNode in elNodesList.ChildNodes)
{
XmlAttribute typeAttrib = elNode.Attributes[0];
XmlAttribute guidAttrib = elNode.Attributes[1];
XmlAttribute nicknameAttrib = elNode.Attributes[2];
XmlAttribute xAttrib = elNode.Attributes[3];
XmlAttribute yAttrib = elNode.Attributes[4];
XmlAttribute lacingAttrib = null;
if (elNode.Attributes.Count > 5)
{
lacingAttrib = elNode.Attributes[5];
}
string typeName = typeAttrib.Value;
string oldNamespace = "Dynamo.Elements.";
if (typeName.StartsWith(oldNamespace))
typeName = "Dynamo.Nodes." + typeName.Remove(0, oldNamespace.Length);
//test the GUID to confirm that it is non-zero
//if it is zero, then we have to fix it
//this will break the connectors, but it won't keep
//propagating bad GUIDs
var guid = new Guid(guidAttrib.Value);
if (guid == Guid.Empty)
{
guid = Guid.NewGuid();
}
string nickname = nicknameAttrib.Value;
double x = Convert.ToDouble(xAttrib.Value);
double y = Convert.ToDouble(yAttrib.Value);
//Type t = Type.GetType(typeName);
TypeLoadData tData;
Type t;
if (!controller.BuiltInTypesByName.TryGetValue(typeName, out tData))
{
//try and get a system type by this name
t = Type.GetType(typeName);
//if we still can't find the type, try the also known as attributes
if (t == null)
{
//try to get the also known as values
foreach (KeyValuePair<string, TypeLoadData> kvp in controller.BuiltInTypesByName)
{
var akaAttribs = kvp.Value.Type.GetCustomAttributes(typeof(AlsoKnownAsAttribute), false);
if (akaAttribs.Count() > 0)
{
if ((akaAttribs[0] as AlsoKnownAsAttribute).Values.Contains(typeName))
{
controller.DynamoViewModel.Log(string.Format("Found matching node for {0} also known as {1}", kvp.Key, typeName));
t = kvp.Value.Type;
}
}
}
}
if (t == null)
{
controller.DynamoViewModel.Log("Could not load node of type: " + typeName);
controller.DynamoViewModel.Log("Loading will continue but nodes might be missing from your workflow.");
//return false;
badNodes.Add(guid);
continue;
}
}
else
t = tData.Type;
dynNodeModel el = dynSettings.Controller.DynamoViewModel.CreateNodeInstance(t, nickname, guid);
if (lacingAttrib != null)
{
LacingStrategy lacing = LacingStrategy.First;
Enum.TryParse(lacingAttrib.Value, out lacing);
el.ArgumentLacing = lacing;
}
// note - this is because the connectors fail to be created if there's not added
// to the canvas
ws.Nodes.Add(el);
el.WorkSpace = ws;
var node = el;
node.X = x;
node.Y = y;
if (el == null)
return false;
el.DisableReporting();
el.LoadElement(elNode); // inject the node properties from the xml
// it has no
if (el is dynFunction)
{
var fun = el as dynFunction;
// we've found a custom node, we need to attempt to load its guid.
// if it doesn't exist (i.e. its a legacy node), we need to assign it one,
// deterministically
Guid funId;
try
{
funId = Guid.Parse(fun.Symbol);
}
catch
{
funId = GuidUtility.Create(GuidUtility.UrlNamespace, nicknameAttrib.Value);
fun.Symbol = funId.ToString();
}
// if it's not a recurisve node and it's not yet loaded, load it
if (funcDefGuid != funId && !this.loadedNodes.ContainsKey(funId))
{
dynSettings.Controller.CustomNodeLoader.GetFunctionDefinition(funId);
fun.Definition = this.loadedNodes[funId];
}
else if ( this.loadedNodes.ContainsKey(funId ))
{
fun.Definition = this.loadedNodes[funId];
}
}
}
#endregion
#region instantiate connectors
foreach (XmlNode connector in cNodesList.ChildNodes)
{
XmlAttribute guidStartAttrib = connector.Attributes[0];
XmlAttribute intStartAttrib = connector.Attributes[1];
XmlAttribute guidEndAttrib = connector.Attributes[2];
XmlAttribute intEndAttrib = connector.Attributes[3];
XmlAttribute portTypeAttrib = connector.Attributes[4];
var guidStart = new Guid(guidStartAttrib.Value);
var guidEnd = new Guid(guidEndAttrib.Value);
int startIndex = Convert.ToInt16(intStartAttrib.Value);
int endIndex = Convert.ToInt16(intEndAttrib.Value);
int portType = Convert.ToInt16(portTypeAttrib.Value);
//find the elements to connect
dynNodeModel start = null;
dynNodeModel end = null;
if (badNodes.Contains(guidStart) || badNodes.Contains(guidEnd))
continue;
foreach (dynNodeModel e in ws.Nodes)
{
if (e.GUID == guidStart)
{
start = e;
}
else if (e.GUID == guidEnd)
{
end = e;
}
if (start != null && end != null)
{
break;
}
}
try
{
if (start != null && end != null && start != end)
{
var newConnector = new dynConnectorModel(
start, end,
startIndex, endIndex,
portType, false
);
ws.Connectors.Add(newConnector);
}
}
catch
{
DynamoCommands.WriteToLogCmd.Execute(string.Format("ERROR : Could not create connector between {0} and {1}.", start.NickName, end.NickName));
}
}
#endregion
#region instantiate notes
if (nNodesList != null)
{
foreach (XmlNode note in nNodesList.ChildNodes)
{
XmlAttribute textAttrib = note.Attributes[0];
XmlAttribute xAttrib = note.Attributes[1];
XmlAttribute yAttrib = note.Attributes[2];
string text = textAttrib.Value;
double x = Convert.ToDouble(xAttrib.Value);
double y = Convert.ToDouble(yAttrib.Value);
//dynNoteView n = Bench.AddNote(text, x, y, ws);
//Bench.AddNote(text, x, y, ws);
var paramDict = new Dictionary<string, object>();
paramDict.Add("x", x);
paramDict.Add("y", y);
paramDict.Add("text", text);
paramDict.Add("workspace", ws);
dynSettings.Controller.DynamoViewModel.AddNoteCommand.Execute(paramDict);
}
}
#endregion
foreach (dynNodeModel e in ws.Nodes)
e.EnableReporting();
ws.FilePath = xmlPath;
controller.PackageManagerClient.LoadPackageHeader(def, funName);
var expression = CompileFunction(def);
controller.FSchemeEnvironment.DefineSymbol(def.FunctionId.ToString(), expression);
}
catch (Exception ex)
{
DynamoCommands.WriteToLogCmd.Execute("There was an error opening the workbench.");
DynamoCommands.WriteToLogCmd.Execute(ex);
def = null;
return false;
}
return true;
}
/// <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>
internal static void Collapse(IEnumerable<dynNode> selectedNodes, dynWorkspace currentWorkspace)
{
var selectedNodeSet = new HashSet<dynNode>(selectedNodes);
// TODO: this code needs refactoring
#region Prompt
//First, prompt the user to enter a name
string newNodeName, newNodeCategory;
string error = "";
do
{
var dialog = new FunctionNamePrompt(dynSettings.Controller.SearchViewModel.Categories, error);
if (dialog.ShowDialog() != true)
{
return;
}
newNodeName = dialog.Text;
newNodeCategory = dialog.Category;
if (dynSettings.Controller.CustomNodeLoader.Contains(newNodeName))
{
error = "A function with this name already exists.";
}
else if (newNodeCategory.Equals(""))
{
error = "Please enter a valid category.";
}
else
{
error = "";
}
} while (!error.Equals(""));
var newNodeWorkspace = new FuncWorkspace(newNodeName, newNodeCategory, 0, 0);
var newNodeDefinition = new FunctionDefinition(Guid.NewGuid());
newNodeDefinition.Workspace = newNodeWorkspace;
#endregion
currentWorkspace.DisableReporting();
#region Determine Inputs and Outputs
//Step 1: determine which nodes will be inputs to the new node
var inputs = new HashSet<Tuple<dynNode, int, Tuple<int, dynNode>>>(
selectedNodeSet
.SelectMany(node => Enumerable.Range(0, node.InPortData.Count)
.Where(node.HasInput)
.Select(data => Tuple.Create(node, data, node.Inputs[data]))
.Where(input => !selectedNodeSet.Contains(input.Item3.Item2))));
var outputs = new HashSet<Tuple<dynNode, int, Tuple<int, dynNode>>>(
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<dynNode>(
inputs
.Select(x => x.Item3.Item2)
.Intersect(outputs.Select(x => x.Item3.Item2)))
.Select(
outerNode =>
{
var node = new dynApply1();
dynNodeUI nodeUI = node.NodeUI;
var elNameAttrib =
node.GetType().GetCustomAttributes(typeof(NodeNameAttribute), true)[0] as
NodeNameAttribute;
if (elNameAttrib != null)
{
nodeUI.NickName = elNameAttrib.Name;
}
nodeUI.GUID = Guid.NewGuid();
//store the element in the elements list
newNodeWorkspace.Nodes.Add(node);
node.WorkSpace = newNodeWorkspace;
node.DisableReporting();
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));
//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.NodeUI.RegisterAllPorts();
dynSettings.Bench.WorkBench.UpdateLayout();
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 => Canvas.GetLeft(node.NodeUI));
double avgY = selectedNodeSet.Average(node => Canvas.GetTop(node.NodeUI));
double leftMost = selectedNodeSet.Min(node => Canvas.GetLeft(node.NodeUI)) + 24;
double topMost = selectedNodeSet.Min(node => Canvas.GetTop(node.NodeUI));
double rightMost = selectedNodeSet.Max(node => Canvas.GetLeft(node.NodeUI) + node.NodeUI.Width);
#endregion
#region Move selection to new workspace
var connectors = new HashSet<dynConnector>(
currentWorkspace.Connectors.Where(
conn => selectedNodeSet.Contains(conn.Start.Owner.NodeLogic)
&& selectedNodeSet.Contains(conn.End.Owner.NodeLogic)));
//Step 2: move all nodes to new workspace
// remove from old
currentWorkspace.Nodes.RemoveAll(selectedNodeSet.Contains);
currentWorkspace.Connectors.RemoveAll(connectors.Contains);
// add to new
newNodeWorkspace.Nodes.AddRange(selectedNodeSet);
newNodeWorkspace.Connectors.AddRange(connectors);
double leftShift = leftMost - 250;
foreach (dynNodeUI node in newNodeWorkspace.Nodes.Select(x => x.NodeUI))
{
Canvas.SetLeft(node, Canvas.GetLeft(node) - leftShift);
Canvas.SetTop(node, Canvas.GetTop(node) - topMost + 120);
}
#endregion
#region Insert new node into the current workspace
//Step 5: insert new node into original workspace
var collapsedNode = new dynFunction(
inputs.Select(x => x.Item1.InPortData[x.Item2].NickName),
outputs
.Where(x => !curriedNodeArgs.Any(y => y.OuterNode == x.Item3.Item2))
.Select(x => x.Item1.OutPortData[x.Item2].NickName),
newNodeDefinition);
collapsedNode.NodeUI.GUID = Guid.NewGuid();
currentWorkspace.Nodes.Add(collapsedNode);
collapsedNode.WorkSpace = currentWorkspace;
dynSettings.Bench.WorkBench.Children.Add(collapsedNode.NodeUI);
Canvas.SetLeft(collapsedNode.NodeUI, avgX);
Canvas.SetTop(collapsedNode.NodeUI, avgY);
#endregion
#region Destroy all hanging connectors
//Step 6: connect inputs and outputs
foreach (dynConnector connector in currentWorkspace.Connectors
.Where(
c =>
selectedNodeSet.Contains(c.Start.Owner.NodeLogic) &&
!selectedNodeSet.Contains(c.End.Owner.NodeLogic))
.ToList())
{
connector.Kill();
}
foreach (dynConnector connector in currentWorkspace.Connectors
.Where(
c =>
!selectedNodeSet.Contains(c.Start.Owner.NodeLogic) &&
selectedNodeSet.Contains(c.End.Owner.NodeLogic)).ToList()
)
{
connector.Kill();
}
#endregion
newNodeWorkspace.Nodes.ForEach(x => x.DisableReporting());
var inConnectors = new List<Tuple<dynNodeUI, int, int>>();
#region Process inputs
//Step 3: insert variables (reference step 1)
foreach (var input in Enumerable.Range(0, inputs.Count).Zip(inputs, Tuple.Create))
{
int inputIndex = input.Item1;
dynNode inputReceiverNode = input.Item2.Item1;
int inputReceiverData = input.Item2.Item2;
dynNode inputNode = input.Item2.Item3.Item2;
int inputData = input.Item2.Item3.Item1;
inConnectors.Add(new Tuple<dynNodeUI, int, int>(inputNode.NodeUI, inputData, inputIndex));
//Create Symbol Node
var node = new dynSymbol
{
Symbol = inputReceiverNode.InPortData[inputReceiverData].NickName
};
dynNodeUI nodeUI = node.NodeUI;
var elNameAttrib =
node.GetType().GetCustomAttributes(typeof(NodeNameAttribute), true)[0] as NodeNameAttribute;
if (elNameAttrib != null)
{
nodeUI.NickName = elNameAttrib.Name;
}
nodeUI.GUID = Guid.NewGuid();
//store the element in the elements list
newNodeWorkspace.Nodes.Add(node);
node.WorkSpace = newNodeWorkspace;
node.DisableReporting();
dynSettings.Bench.WorkBench.Children.Add(nodeUI);
//Place it in an appropriate spot
Canvas.SetLeft(nodeUI, 0);
Canvas.SetTop(nodeUI, inputIndex * (50 + node.NodeUI.Height));
dynSettings.Bench.WorkBench.UpdateLayout();
var curriedNode = curriedNodeArgs.FirstOrDefault(
x => x.OuterNode == inputNode);
if (curriedNode == null)
{
//Connect it (new dynConnector)
newNodeWorkspace.Connectors.Add(new dynConnector(
nodeUI,
inputReceiverNode.NodeUI,
0,
inputReceiverData,
0,
false));
}
else
{
//Connect it to the applier
newNodeWorkspace.Connectors.Add(new dynConnector(
nodeUI,
curriedNode.InnerNode.NodeUI,
0,
0,
0,
false));
//Connect applier to the inner input receiver
newNodeWorkspace.Connectors.Add(new dynConnector(
curriedNode.InnerNode.NodeUI,
inputReceiverNode.NodeUI,
0,
inputReceiverData,
0,
false));
}
}
#endregion
#region Process outputs
//List of all inner nodes to connect an output. Unique.
var outportList = new List<Tuple<dynNode, int>>();
var outConnectors = new List<Tuple<dynNodeUI, int, int>>();
int i = 0;
foreach (var output in outputs)
{
if (outportList.All(x => !(x.Item1 == output.Item1 && x.Item2 == output.Item2)))
{
dynNode outputSenderNode = output.Item1;
int outputSenderData = output.Item2;
dynNode outputReceiverNode = output.Item3.Item2;
if (curriedNodeArgs.Any(x => x.OuterNode == outputReceiverNode))
continue;
outportList.Add(Tuple.Create(outputSenderNode, outputSenderData));
//Create Symbol Node
var node = new dynOutput
{
Symbol = outputSenderNode.OutPortData[outputSenderData].NickName
};
dynNodeUI nodeUI = node.NodeUI;
var elNameAttrib =
node.GetType().GetCustomAttributes(typeof(NodeNameAttribute), false)[0] as NodeNameAttribute;
if (elNameAttrib != null)
{
nodeUI.NickName = elNameAttrib.Name;
}
nodeUI.GUID = Guid.NewGuid();
//store the element in the elements list
newNodeWorkspace.Nodes.Add(node);
node.WorkSpace = newNodeWorkspace;
node.DisableReporting();
dynSettings.Bench.WorkBench.Children.Add(nodeUI);
//Place it in an appropriate spot
Canvas.SetLeft(nodeUI, rightMost + 75 - leftShift);
Canvas.SetTop(nodeUI, i * (50 + node.NodeUI.Height));
dynSettings.Bench.WorkBench.UpdateLayout();
newNodeWorkspace.Connectors.Add(new dynConnector(
outputSenderNode.NodeUI,
nodeUI,
outputSenderData,
0,
0,
false));
i++;
}
}
//Connect outputs to new node
foreach (var output in outputs)
{
//Node to be connected to in CurrentSpace
dynNode outputSenderNode = output.Item1;
//Port to be connected to on outPutNode_outer
int outputSenderData = output.Item2;
int outputReceiverData = output.Item3.Item1;
dynNode 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(new Tuple<dynNodeUI, int, int>(outputReceiverNode.NodeUI,
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.Connectors.Add(new dynConnector(
outputSenderNode.NodeUI,
curriedNode.InnerNode.NodeUI,
outputSenderData,
targetPortIndex + 1,
0));
}
}
#endregion
#region Make new workspace invisible
//Step 4: make nodes invisible
// and update positions
foreach (dynNodeUI node in newNodeWorkspace.Nodes.Select(x => x.NodeUI))
node.Visibility = Visibility.Hidden;
foreach (dynConnector connector in newNodeWorkspace.Connectors)
connector.Visible = false;
#endregion
//set the name on the node
collapsedNode.NodeUI.NickName = newNodeName;
currentWorkspace.Nodes.Remove(collapsedNode);
dynSettings.Bench.WorkBench.Children.Remove(collapsedNode.NodeUI);
// save and load the definition from file
var path = dynSettings.Controller.SaveFunctionOnly(newNodeDefinition);
dynSettings.Controller.CustomNodeLoader.SetNodeInfo(newNodeName, newNodeCategory, newNodeDefinition.FunctionId, path);
dynSettings.Controller.SearchViewModel.Add(newNodeName, newNodeCategory, newNodeDefinition.FunctionId);
DynamoCommands.CreateNodeCmd.Execute(new Dictionary<string, object>()
{
{"name", collapsedNode.Definition.FunctionId.ToString() },
{"x", avgX },
{"y", avgY }
});
var newlyPlacedCollapsedNode = currentWorkspace.Nodes
.Where(node => node is dynFunction)
.First(node => ((dynFunction)node).Definition.FunctionId == newNodeDefinition.FunctionId);
newlyPlacedCollapsedNode.DisableReporting();
dynSettings.Bench.WorkBench.UpdateLayout(); // without doing this, connectors fail to be created
foreach (var nodeTuple in inConnectors)
{
currentWorkspace.Connectors.Add(
new dynConnector(
nodeTuple.Item1,
newlyPlacedCollapsedNode.NodeUI,
nodeTuple.Item2,
nodeTuple.Item3,
0,
true));
}
foreach (var nodeTuple in outConnectors)
{
currentWorkspace.Connectors.Add(
new dynConnector(
newlyPlacedCollapsedNode.NodeUI,
nodeTuple.Item1,
nodeTuple.Item2,
nodeTuple.Item3,
0,
true));
}
newlyPlacedCollapsedNode.EnableReporting();
currentWorkspace.EnableReporting();
}
internal FunctionDefinition NewFunction(Guid id,
string name,
string category,
string description,
bool display,
double workspaceOffsetX = DynamoView.CANVAS_OFFSET_X,
double workspaceOffsetY = DynamoView.CANVAS_OFFSET_Y)
{
//Add an entry to the funcdict
var workSpace = new FuncWorkspace(
name, category, description, workspaceOffsetX, workspaceOffsetY)
{
WatchChanges = true
};
_model.Workspaces.Add(workSpace);
List<dynNodeModel> newElements = workSpace.Nodes.ToList();
List<dynConnectorModel> newConnectors = workSpace.Connectors.ToList();
var functionDefinition = new FunctionDefinition(id)
{
Workspace = workSpace
};
Controller.CustomNodeManager.AddFunctionDefinition(functionDefinition.FunctionId, functionDefinition);
// add the element to search
Controller.SearchViewModel.Add(name, category, description, id);
if (display)
{
if (!ViewingHomespace)
{
var def = Controller.CustomNodeManager.GetDefinitionFromWorkspace(CurrentSpace);
if (def != null)
SaveFunction(def);
}
_model.CurrentSpace = workSpace;
}
return functionDefinition;
}
