private List <IVisualNode> RetrieveNodesFromStorage(IStorage storage)
{
DataHeader header = new DataHeader();
List <IVisualNode> nodeList = new List <IVisualNode>();
int nodeCount = storage.ReadInteger(FieldCode.NodeCount);
for (int i = 0; i < nodeCount; i++)
{
header.Deserialize(storage);
IVisualNode node = VisualNode.Create(this.graphController, storage);
nodeList.Add(node);
}
return(nodeList);
}
public bool GetNodeType(uint nodeId, out string returnType)
{
VisualNode node = this.GetVisualNode(nodeId);
returnType = string.Empty;
if (node != null)
{
returnType = node.ReturnType;
return(true);
}
else
{
return(false);
}
}
public bool GetNodeState(uint nodeId, out States nodeState)
{
VisualNode node = this.GetVisualNode(nodeId);
if (node != null)
{
nodeState = node.NodeStates;
return(true);
}
else
{
nodeState = States.None;
return(false);
}
}
public bool GetReplicationText(uint compId, int index, out string text)
{
VisualNode node = GetVisualNode(compId);
if (node.VisualType != NodeType.Function)
{
throw new InvalidOperationException("node must be function Node");
}
else
{
FunctionNode fNode = node as FunctionNode;
text = fNode.GetReplicationText(index);
}
return(true);
}
private void OnWarningTimeOut(object sender, EventArgs e)
{
VisualNode node = graphController.GetVisualNode(this.OwnerId);
//Terminate DispatcherTimer
this.timer.Stop();
this.timer = null;
//Clear state
this.content = null;
this.ErrType = ErrorType.None;
//Redraw
node.Dirty = true;
node.Compose();
}
public bool TransientUpdateReplicationText(uint compId, string text, int replicationIndex)
{
VisualNode node = GetVisualNode(compId);
if (node.VisualType != NodeType.Function)
{
throw new InvalidOperationException("Replication Guides can only be added to functio nodes");
}
else
{
FunctionNode fNode = node as FunctionNode;
fNode.UpdateReplicationGuides(text, replicationIndex);
}
edgeController.UpdateEdgeConnectTo(node);
return(true);
}
public void ClearPreviewSelection(uint componentId)
{
IVisualNode selectedNode = null;
nodeCollection.TryGetValue(componentId, out selectedNode);
VisualNode node = selectedNode as VisualNode;
if (node != null)
{
node.PreviewSelected = node.Selected;
node.Compose(); // Optionally redraw the node.
}
else
{
edgeController.ClearPreviewSelection(componentId);
}
}
private bool HandleBeginNodeEdit(GraphCommand command)
{
uint nodeId = (uint)command.GetArgument(0);
NodePart nodePart = ((NodePart)command.GetArgument(1));
VisualNode node = this.GetVisualNode(nodeId);
if (nodePart == NodePart.Text)
{
this.previousText = node.Text;
}
else if (nodePart == NodePart.Caption)
{
this.previousText = node.Caption;
}
node.EnableEdit(nodePart, -1);
return(true);
}
private bool HandleTogglePreview(GraphCommand command)
{
uint bubbleId = (uint)command.GetArgument(0);
if (bubbleId == uint.MaxValue)
{
return(ToggleAllPreviews());
}
PreviewBubble previewBubble = bubbleCollection[bubbleId] as PreviewBubble;
if (previewBubble == null)
{
return(false);
}
VisualNode node = GetVisualNode(previewBubble.OwnerId);
if (node == null)
{
return(false);
}
List <IVisualNode> nodeList = new List <IVisualNode>();
nodeList.Add(node);
undoRedoRecorder.BeginGroup();
undoRedoRecorder.RecordNodeModificationForUndo(nodeList);
undoRedoRecorder.EndGroup();
if (node.NodeStates.HasFlag(States.PreviewHidden))
{
node.ClearState(States.PreviewHidden);
CurrentSynchronizer.BeginQueryNodeValue(node.NodeId);
}
else
{
node.SetNodeState(States.PreviewHidden);
}
previewBubble.Collapse(node.NodeStates.HasFlag(States.PreviewHidden));
return(true);
}
internal void UpdateVariablesDefinedInNode(VisualNode node, bool isPriority)
{
List <string> mappingToRemove = new List <string>();
List <string> variables = node.GetDefinedVariables(false);
if (null != variables)
{
foreach (KeyValuePair <string, List <uint> > kvp in this.variableNodesMap)
{
if (!variables.Contains(kvp.Key) && kvp.Value.Contains(node.NodeId))
{
mappingToRemove.Add(kvp.Key);
}
}
}
foreach (string variable in mappingToRemove)
{
this.RemoveDefinition(variable, node.NodeId);
}
if (null != variables)
{
foreach (string variable in variables)
{
this.AddDefinition(variable, node.NodeId, isPriority);
}
}
if (null != undefinedVarsTracker && (mappingToRemove.Count > 0))
{
if (!undefinedVarsTracker.ContainsKey(node.NodeId))
{
undefinedVarsTracker.Add(node.NodeId, new List <string>());
}
foreach (string variable in mappingToRemove)
{
undefinedVarsTracker[node.NodeId].Add(variable);
}
}
}
private void GenerateMenuItems()
{
Dictionary <int, string> list = new Dictionary <int, string>();
VisualNode node = graphController.GetVisualNode(nodeId);
if (nodeId == uint.MaxValue)
{
libraryItemCollection = new Dictionary <int, LibraryItem>();
}
if (null == node)
{
return;
}
switch (node.VisualType)
{
case NodeType.Function:
GetFunctionNodeMenuItems();
break;
case NodeType.Driver:
GetDriverNodeMenuItems(list);
break;
case NodeType.CodeBlock:
GetCodeBlockNodeMenuItems(list);
break;
case NodeType.Identifier:
GetIdentifierNodeMenuItems();
break;
case NodeType.Property:
GetPropertyNodeMenuItems();
break;
default:
return;
}
return;
}
private void GetNodeOptions(uint nodeId, out Dictionary <int, string> nodeItems)
{
VisualNode node = this.graphController.GetVisualNode(nodeId);
nodeItems = new Dictionary <int, string>();
if (node.VisualType == NodeType.Function)
{
FunctionNode fNode = ((FunctionNode)node);
if (fNode.GetAddReplicationState() == true)
{
nodeItems.Add(Configurations.AddReplicationGuides, "Add Replication Guides");
}
if (fNode.GetRemoveReplicationState() == true)
{
nodeItems.Add(Configurations.RemoveReplicationGuides, "Remove Replication Guides");
}
}
nodeItems.Add(Configurations.DeleteNode, "Delete Node");
}
internal override void SetContent(object content)
{
this.content = content;
previewType &= ~PreviewTypes.String;
previewType &= ~PreviewTypes.Bitmap;
previewType &= ~PreviewTypes.Unknown;
VisualNode node = graphController.GetVisualNode(this.nodeId);
DesignScriptStudio.Renderer.ThumbnailData thumbnailData = null;
thumbnailData = content as DesignScriptStudio.Renderer.ThumbnailData;
if (null != thumbnailData)
{
int stride = thumbnailData.width * 4;
this.content = BitmapSource.Create(thumbnailData.width, thumbnailData.height,
96, 96, PixelFormats.Bgra32, null, thumbnailData.pixels, stride);
previewType |= PreviewTypes.Bitmap;
}
else if (null != content as BitmapSource)
{
this.content = content as BitmapSource;
previewType |= PreviewTypes.Bitmap;
}
else
{
if (content == null)
{
condensedString = null;
}
else
{
condensedString = Condense(content.ToString());
}
previewType |= PreviewTypes.String;
}
this.extendedBubbleWidth = double.MinValue;
this.extendedBubbleHeight = double.MinValue;
node.Dirty = true;
}
public bool GetNodeText(uint compId, NodePart nodePart, out string text)
{
text = string.Empty;
VisualNode newNode = this.GetVisualNode(compId);
if (null == newNode)
{
return(false);
}
if (nodePart == NodePart.Caption)
{
text = newNode.Caption;
return(true);
}
else if (nodePart == NodePart.Text)
{
text = newNode.Text;
return(true);
}
return(false);
}
// if it is node, once it is selected, it will be brought to the top
// if it is bubble, if its selected, it will follow its owners' z-index, if unselected, send to back,
// edge is different, when the edge is moving, it is drawn in another drawingVisual which is topmost,
// when the edge moving is done, it will draw on the old/own drawingVisual
//
private void RearrangeNodeAndBubbleVisual(VisualNode node, bool bringToFront)
{
if (null == visualHost)
return;
uint errorBubbleId = node.GetErrorBubbleId();
uint previewBubbleId = node.GetPreviewBubbleId();
if (bringToFront)
{
visualHost.RearrangeDrawingVisual(node.NodeId, bringToFront, uint.MaxValue);
if (errorBubbleId != uint.MaxValue)
visualHost.RearrangeDrawingVisual(errorBubbleId, bringToFront, node.NodeId);
if (previewBubbleId != uint.MaxValue)
visualHost.RearrangeDrawingVisual(previewBubbleId, bringToFront, node.NodeId);
}
else
{
if (errorBubbleId != uint.MaxValue)
visualHost.RearrangeDrawingVisual(errorBubbleId, bringToFront, uint.MaxValue);
if (previewBubbleId != uint.MaxValue)
visualHost.RearrangeDrawingVisual(previewBubbleId, bringToFront, uint.MaxValue);
}
}
internal void UpdateVariablesDefinedInNode(VisualNode node, bool isPriority)
{
List<string> mappingToRemove = new List<string>();
List<string> variables = node.GetDefinedVariables(false);
if (null != variables)
{
foreach (KeyValuePair<string, List<uint>> kvp in this.variableNodesMap)
{
if (!variables.Contains(kvp.Key) && kvp.Value.Contains(node.NodeId))
mappingToRemove.Add(kvp.Key);
}
}
foreach (string variable in mappingToRemove)
this.RemoveDefinition(variable, node.NodeId);
if (null != variables)
{
foreach (string variable in variables)
this.AddDefinition(variable, node.NodeId, isPriority);
}
if (null != undefinedVarsTracker && (mappingToRemove.Count > 0))
{
if (!undefinedVarsTracker.ContainsKey(node.NodeId))
undefinedVarsTracker.Add(node.NodeId, new List<string>());
foreach (string variable in mappingToRemove)
undefinedVarsTracker[node.NodeId].Add(variable);
}
}
private void EstablishExplicitInputConnection(VisualNode endNode, Connection connection, List<IVisualNode> modifiedNodes)
{
VisualNode startNode = (VisualNode)nodeCollection[connection.OtherNode];
uint startSlotId = startNode.GetOutputSlot(connection.OtherIndex);
uint endSlotId = endNode.GetInputSlot(connection.LocalIndex);
Slot outputSlot = GetSlot(startSlotId) as Slot;
Slot inputSlot = GetSlot(endSlotId) as Slot;
edgeController.CreateLinkingEdge(outputSlot, inputSlot);
startNode.HandleNewConnection(startSlotId);
endNode.HandleNewConnection(endSlotId);
modifiedNodes.Add(startNode);
modifiedNodes.Add(endNode);
}
internal void UpdateEdgeConnectTo(VisualNode node)
{
uint[] inputs = node.GetInputSlots();
uint[] outputs = node.GetOutputSlots();
if (inputs != null)
{
foreach (uint slotId in inputs)
{
foreach (VisualEdge visualEdge in edgeCollection.Values)
if (visualEdge.EndSlotId == slotId)
visualEdge.UpdateControlPoint();
}
}
if (outputs != null)
{
foreach (uint slotId in outputs)
{
foreach (VisualEdge visualEdge in edgeCollection.Values)
if (visualEdge.StartSlotId == slotId)
visualEdge.UpdateControlPoint();
}
}
UpdateDirtyEdges(null);
}
private bool HandleSelectedMenuItem(GraphCommand command)
{
int menuItemId = (int)command.GetArgument(0);
double mouseX = ((double)command.GetArgument(1));
double mouseY = ((double)command.GetArgument(2));
uint nodeId = (uint)command.GetArgument(3);
NodePart part = ((NodePart)command.GetArgument(4));
LibraryItem selectedItem = new LibraryItem();
VisualNode node = this.GetVisualNode(nodeId);
if (itemsProvider != null)
{
selectedItem = this.itemsProvider.GetItem(menuItemId);
}
if (selectedItem == null) //No match in the library
{
if (part == NodePart.NorthWest)
{
this.HandleTopLeftSelectedItem(menuItemId, nodeId);
}
else if (menuItemId == Configurations.ConvertNodeToCode)
{
HandleConvertSelectionToCode();
return(true);
}
else if (menuItemId < Configurations.PropertyBase)
{
// @TODO(Joy): Use switch-case for "menuItemId".
ProcessPreviewMenuItems(menuItemId, nodeId);
UpdateDirtyNodes();
return(true);
}
}
else //Item found in library
{
if (selectedItem.Children != null && selectedItem.Children.Count > 0)
{
selectedItem = selectedItem.Children[0];
}
LibraryItem.MemberType itemType = this.GetItemType(menuItemId);
DeltaNodes deltaNodes = new DeltaNodes();
VisualNode newNode = null;
if (part == NodePart.NorthEast)
{
if (selectedItem.Type == LibraryItem.MemberType.InstanceProperty)
{
if (selectedItem.ItemType == NodeType.Function)
{
newNode = this.CreateMethodNode(mouseX, mouseY, selectedItem.Assembly, selectedItem.QualifiedName, selectedItem.ArgumentTypes);
}
else
{
newNode = this.CreatePropertyNode(mouseX, mouseY, selectedItem.Assembly, selectedItem.QualifiedName, selectedItem.ArgumentTypes);
}
deltaNodes.AppendToAddedNodes(newNode);
}
else if (selectedItem.Type == LibraryItem.MemberType.InstanceMethod)
{
newNode = this.CreateMethodNode(mouseX, mouseY, selectedItem.Assembly, selectedItem.QualifiedName, selectedItem.ArgumentTypes);
deltaNodes.AppendToAddedNodes(newNode);
}
if (newNode != null && (null != deltaNodes.AddedNodes) && deltaNodes.AddedNodes.Count > 0)
{
// @keyu: If we are acessing its member function or
// property, there is no reason to mark this node as
// dirty. Comment it out to avoid to recreate object.
//
// deltaNodes.AppendToModifiedNodes(node);
Slot inputSlot = this.GetSlot(newNode.GetInputSlot(0)) as Slot;
Slot outputSlot = this.GetSlot(node.GetOutputSlot(0)) as Slot;
this.undoRedoRecorder.BeginGroup();
this.undoRedoRecorder.RecordRuntimeStatesForUndo(this.graphProperties.RuntimeStates);
this.undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
this.graphProperties.RuntimeStates.AddVariablesDefinedInNode(newNode, false);
this.edgeController.CreateLinkingEdge(outputSlot, inputSlot);
this.undoRedoRecorder.RecordNodeCreationForUndo(deltaNodes.AddedNodes);
this.undoRedoRecorder.EndGroup();
//After EstablishLinkingConnection() is executed, the nodes in the nodeToModify would already be modified
this.SynchronizeToLiveRunner(deltaNodes);
}
}
else if (part == NodePart.North)
{
if (itemType == LibraryItem.MemberType.Constructor)
{
deltaNodes.AppendToModifiedNodes(node);
deltaNodes.AppendToModifiedNodes(FindAssociatedNodesFromNodes(deltaNodes.ModifiedNodes));
this.undoRedoRecorder.BeginGroup();
this.undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
//this.undoRedoRecorder.RecordEdgeModificationForUndo(edgeController.FindEdgeConnectTo(node));
((FunctionNode)node).ChangeConstructor(selectedItem.QualifiedName, selectedItem.ArgumentTypes, selectedItem.ArgumentNames);
this.undoRedoRecorder.EndGroup();
//After ChangeConstructor() is executed, the nodes in the nodeToModify would already be modified
this.SynchronizeToLiveRunner(deltaNodes);
}
else if (itemType == LibraryItem.MemberType.InstanceProperty)
{
deltaNodes.AppendToRemovedNodes(node);
deltaNodes.AppendToModifiedNodes(this.FindAssociatedNodesFromNodes(deltaNodes.RemovedNodes));
newNode = this.CreatePropertyNode(mouseX, mouseY, selectedItem.Assembly, selectedItem.QualifiedName, selectedItem.ArgumentTypes);
deltaNodes.AppendToAddedNodes(newNode);
this.undoRedoRecorder.BeginGroup();
this.undoRedoRecorder.RecordRuntimeStatesForUndo(this.graphProperties.RuntimeStates);
this.undoRedoRecorder.RecordNodeDeletionForUndo(deltaNodes.RemovedNodes);
this.undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
this.TransferInformationFromMethodToProperty(node, newNode);
this.undoRedoRecorder.RecordNodeCreationForUndo(deltaNodes.AddedNodes);
this.DeleteNodes(deltaNodes.RemovedNodes);
this.undoRedoRecorder.EndGroup();
//After DeleteNodes() is executed, the nodes in the nodeToModify would already be modified
this.SynchronizeToLiveRunner(deltaNodes);
}
else if (itemType == LibraryItem.MemberType.InstanceMethod)
{
deltaNodes.AppendToModifiedNodes(node);
deltaNodes.AppendToModifiedNodes(FindAssociatedNodesFromNodes(deltaNodes.ModifiedNodes));
this.undoRedoRecorder.BeginGroup();
this.undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
((FunctionNode)node).ChangeMethod(selectedItem.QualifiedName, selectedItem.ArgumentTypes);
this.undoRedoRecorder.EndGroup();
//After ChangeConstructor() is executed, the nodes in the nodeToModify would already be modified
this.SynchronizeToLiveRunner(deltaNodes);
}
}
}
this.UpdateDirtyNodes();
edgeController.UpdateEdgeConnectTo(node);
return(true);
}
internal void Compose()
{
GraphController controller = graphController as GraphController;
IGraphVisualHost visualHost = controller.GetVisualHost();
if (null == visualHost)
{
return; // Running in headless mode, draw no further.
}
DrawingVisual bubbleVisual = visualHost.GetDrawingVisualForBubble(this.bubbleId);
DrawingContext drawingContext = bubbleVisual.RenderOpen();
string text = this.content as string;
if (string.IsNullOrEmpty(text))
{
drawingContext.Close();
return;
}
if (this.ErrType == ErrorType.None)
{
ErrorManager.HandleError(new InvalidOperationException("'errorType' is not set"));
}
VisualNode node = graphController.GetVisualNode(this.OwnerId);
this.anchorPoint.X = node.Width / 2;
this.anchorPoint.Y = -Configurations.InfoBubbleTopMargin;
this.anchorPoint = new Point((int)this.anchorPoint.X, (int)this.anchorPoint.Y);
this.arrowLeft = new Point((int)this.anchorPoint.X - Configurations.InfoBubbleArrowWidthHalf, (int)this.anchorPoint.Y - Configurations.InfoBubbleArrowHeight);
this.arrowRight = new Point((int)this.anchorPoint.X + Configurations.InfoBubbleArrowWidthHalf, (int)this.anchorPoint.Y - Configurations.InfoBubbleArrowHeight);
this.arrowLeft.Offset(-1, -2);
this.arrowRight.Offset(1, -2);
double textLength;
int textHorizontalMargin;
int textVerticalMargin;
FormattedText newText;
SolidColorBrush textColor;
SolidColorBrush backgroundColor;
Pen borderPen;
if (this.ErrType == ErrorType.Warning)
{
textColor = Configurations.ErrorBubbleWarningTextColor;
borderPen = Configurations.ErrorBubbleWarningBorderPen;
backgroundColor = Configurations.ErrorBubbleWarningBackground;
}
else
{
textColor = Configurations.ErrorBubbleErrorTextColor;
borderPen = Configurations.ErrorBubbleErrorBorderPen;
//if (this.node.Selected == true)
backgroundColor = Configurations.ErrorBubbleErrorBackgroundActive;
//else
// backgroundColor = Configurations.ErrorBubbleErrorBackgroundNonActive;
}
textHorizontalMargin = Configurations.InfoBubbleMargin;
textVerticalMargin = Configurations.InfoBubbleMargin;
newText = new FormattedText(text,
Configurations.culture,
FlowDirection.LeftToRight,
Configurations.TypeFace,
Configurations.InfoBubbleText,
textColor);
newText.LineHeight = Configurations.InfoBubbleText;
textLength = newText.WidthIncludingTrailingWhitespace;
this.rectWidth = (int)(textLength + textHorizontalMargin * 2);
this.rectHeight = (int)(textVerticalMargin * 2 + newText.Height);
if (this.rectWidth < Configurations.InfoBubbleMinWidth)
{
this.rectWidth = Configurations.InfoBubbleMinWidth;
}
this.rectPoint = new Point((int)(this.anchorPoint.X - this.rectWidth / 2) + 0.5, (int)(this.anchorPoint.Y - Configurations.InfoBubbleArrowHeight - this.rectHeight) + 0.5);
//Draw Bubble
base.DrawBubble(drawingContext, backgroundColor, borderPen, true);
//Draw Text
drawingContext.DrawText(newText, new Point(this.rectPoint.X + textHorizontalMargin, this.rectPoint.Y + textVerticalMargin));
drawingContext.Close();
TranslateTransform transform = bubbleVisual.Transform as TranslateTransform;
transform.X = node.X;
transform.Y = node.Y;
}
private bool HandleMouseUp(GraphCommand command)
{
MouseButton button = ((MouseButton)command.GetArgument(0));
uint compId = ((uint)command.GetArgument(1));
NodePart nodePart = ((NodePart)command.GetArgument(2));
int slotIndex = ((int)command.GetArgument(3));
ModifierKeys modifiers = ((ModifierKeys)command.GetArgument(4));
if (currentDragState == DragState.None)
{
IVisualNode node = null;
VisualNode visNode = null;
nodeCollection.TryGetValue(compId, out node);
if (null != node)
{
visNode = node as VisualNode;
}
switch (nodePart)
{
case NodePart.InputSlot:
case NodePart.OutputSlot:
case NodePart.NorthWest:
case NodePart.South:
case NodePart.Caption:
case NodePart.Text:
case NodePart.North:
case NodePart.ReplicationGuide:
case NodePart.InputLabel:
break;
case NodePart.NorthEast:
visNode.ToggleContextualMenu(nodePart);
break;
case NodePart.Preview:
//visNode.TogglePreview();
break;
case NodePart.PreviewNorthEast:
//visNode.ToggleContextualMenu(nodePart);
break;
default:
if (!modifiers.HasFlag(ModifierKeys.Control) && !modifiers.HasFlag(ModifierKeys.Shift))
{
ClearSelectionInternal();
}
break;
}
if (visualHost != null && visNode != null && visNode.Selected)
{
visualHost.ScrollToVisual(visualHost.GetDrawingVisualForNode(visNode.NodeId));
}
}
else if (currentDragState != DragState.CurveDrawing && currentDragState != DragState.EdgeReconnection) // for click and drag
{
currentDragState = DragState.None; // it won't end when mouseup on the same slot
}
// IDE-1371
selectionBox.UpdateSelectionBox(GetSelectedNodes());
return(true);
}
public void SetMouseCursor(uint nodeId, NodePart nodePart, int index, ModifierKeys modifiers, bool isMouseButtonDown, double x, double y)
{
if (0 == nodeId)
{
// When the UI calls this method, we are only expecting two possible
// value ranges for 'nodeId': a "uint.MaxValue" when the 'nodeId' is
// invalid, or a positive number. This should not be zero, if it is,
// do let me know. - Ben.
throw new ArgumentException("121B20BE: Invalid argument!", "nodeId");
}
if (currentDragState == DragState.NodeRepositioning)
{
if (!isMouseButtonDown)
{
return;
}
foreach (DraggedNode draggedNode in dragSet)
{
if (visualHost != null)
{
VisualNode node = (VisualNode)draggedNode.node;
DrawingVisual visual = visualHost.GetDrawingVisualForNode(node.NodeId);
TranslateTransform transform = visual.Transform as TranslateTransform;
transform.X = x - draggedNode.DeltaX;
transform.Y = y - draggedNode.DeltaY;
node.X = transform.X;
node.Y = transform.Y;
this.TransformBubble(node, transform);
}
}
edgeController.UpdateSelectedEdges();
selectionBox.UpdateSelectionBox(x, y);
}
else if ((currentDragState == DragState.CurveDrawing) || (currentDragState == DragState.EdgeReconnection))
{
if (nodePart != NodePart.None && nodeId == uint.MaxValue)
{
throw new InvalidOperationException("Nodepard and NodeId are not in consistent (914C54A64BFD)");
}
VisualNode node = null;
edgeConnection = EdgeConnectionFlag.None;
if (nodePart != NodePart.None)
{
node = GetVisualNode(nodeId);
}
else
{
if (lastHoveredNodeId != uint.MaxValue && lastHoveredNodeId != edgeController.GetCurrentlySelectedNodeId())
{
node = GetVisualNode(lastHoveredNodeId);
node.PreviewSelected = node.Selected;//reset the original state of the node
RearrangeNodeAndBubbleVisual(node, false);
}
}
//verification
List <IVisualNode> nodeToModify;
edgeConnection = edgeController.AttemptConnectEdge(node, nodePart, index, out nodeToModify);
if (nodePart != NodePart.None)
{
if ((edgeConnection == EdgeConnectionFlag.NewEdge || edgeConnection == EdgeConnectionFlag.ReconnectEdge) &&
(nodePart == NodePart.InputSlot || nodePart == NodePart.InputLabel || nodePart == NodePart.ReplicationGuide))
{
node.SetHoveredIndex(index);
}
node.PreviewSelected = true;
RearrangeNodeAndBubbleVisual(node, true);
}
if (edgeConnection != EdgeConnectionFlag.None && edgeConnection != EdgeConnectionFlag.Illegal)
{
edgeController.DrawConnectingEdgeTo();
}
else
{
edgeController.DrawConnectingEdgeTo(new Point(x, y));
}
lastHoveredNodeId = nodeId;
if (null != node)
{
node.Compose(); // Optionally redraw the node.
}
}
}
internal EdgeConnectionFlag AttemptConnectEdge(VisualNode node, NodePart nodePart, int index, out List<IVisualNode> nodeToModify)
{
nodeToModify = new List<IVisualNode>();
connectNodeId = uint.MaxValue;
connectSlotId = uint.MaxValue;
connectSlotType = SlotType.None;
SlotType startSlotType = SlotType.None;
if (node != null)
{
connectNodeId = node.NodeId;
if (graphController.CurrentDragState == DragState.CurveDrawing)
{
if (currentlySelectedNodeId == connectNodeId)
return EdgeConnectionFlag.None;
startSlotType = currentlySelectedSlotType;
}
else
{
foreach (uint slotId in reconnectingSlots) //try to connect any of the reconnecting node
{
if (connectNodeId == graphController.GetSlot(slotId).Owners.Last())
return EdgeConnectionFlag.None;
}
if (graphController.GetSlot(lastConnectedSlotId).SlotType == SlotType.Output)
startSlotType = SlotType.Input;
else
startSlotType = SlotType.Output;
}
if (nodePart == NodePart.InputSlot || nodePart == NodePart.InputLabel || nodePart == NodePart.ReplicationGuide)
{
connectSlotType = SlotType.Input;
connectSlotId = node.GetInputSlot(index);
}
else if (nodePart == NodePart.OutputSlot || (nodePart == NodePart.Text && node.VisualType != NodeType.CodeBlock)) // user can only connect to the output slot of the CBN
{
connectSlotType = SlotType.Output;
connectSlotId = node.GetOutputSlot(index);
}
else if (node.VisualType == NodeType.Identifier && nodePart == NodePart.Caption)
{
if (startSlotType == SlotType.Output)
{
connectSlotType = SlotType.Input;
connectSlotId = node.GetInputSlot(0);
}
else if (startSlotType == SlotType.Input)
{
connectSlotType = SlotType.Output;
connectSlotId = node.GetOutputSlot(0);
}
}
}
if (graphController.CurrentDragState == DragState.CurveDrawing)
{
if (connectSlotId == 0 || connectSlotId == uint.MaxValue)
return EdgeConnectionFlag.None;
if (currentlySelectedSlotType == connectSlotType)
return EdgeConnectionFlag.Illegal;
// Check if these is a edge between the two slots already
if (startSlotType == SlotType.Input)
{
this.inputSlotId = currentlySelectedSlotId;
this.outputSlotId = connectSlotId;
}
else
{
this.inputSlotId = connectSlotId;
this.outputSlotId = currentlySelectedSlotId;
}
var entry = edgeCollection.FirstOrDefault(x => IsAdded(x.Value));
if ((edgeCollection.Count() != 0) && (entry.Value != null))
return EdgeConnectionFlag.None;
nodeToModify.Add(graphController.GetVisualNode(currentlySelectedNodeId));
nodeToModify.Add(node);
//check if it is a edge replace(the input slot is connect to other node already)
if (FindEdgeToBeReplaced(out edgeToBeReplaced))
{
nodeToModify.Add(graphController.GetVisualNode
(graphController.GetSlot(edgeToBeReplaced.StartSlotId).Owners.Last()));
nodeToModify.Add(graphController.GetVisualNode
(graphController.GetSlot(edgeToBeReplaced.EndSlotId).Owners.Last()));
}
return EdgeConnectionFlag.NewEdge;
}
else
{
nodeToModify.Add(graphController.GetVisualNode
(graphController.GetSlot(lastConnectedSlotId).Owners.Last()));
foreach (uint slotId in reconnectingSlots)
{
nodeToModify.Add(graphController.GetVisualNode
(graphController.GetSlot(slotId).Owners.Last()));
}
if (connectSlotId == 0 || connectSlotId == uint.MaxValue)
return EdgeConnectionFlag.None;
if (connectSlotType != graphController.GetSlot(lastConnectedSlotId).SlotType)
return EdgeConnectionFlag.Illegal;
if (lastConnectedSlotId == connectSlotId) // node modification is needed only when the it reconnect to different slot
{
nodeToModify = new List<IVisualNode>();
}
else
{
nodeToModify.Add(node);
//check if it is a edge replace(the input slot is connect to other node already)
if (FindEdgeToBeReplaced(reconnectingSlots[0], out edgeToBeReplaced))
{
if (!reconnectingEdges.Contains(edgeToBeReplaced.EdgeId))
{
nodeToModify.Add(graphController.GetVisualNode
(graphController.GetSlot(edgeToBeReplaced.StartSlotId).Owners.Last()));
nodeToModify.Add(graphController.GetVisualNode
(graphController.GetSlot(edgeToBeReplaced.EndSlotId).Owners.Last()));
}
}
}
return EdgeConnectionFlag.ReconnectEdge;
}
}
public bool GetNodePartRegion(uint compId, NodePart nodePart, Point mousePt, out Rect result, out NodeType type)
{
result = new Rect();
type = NodeType.None;
IVisualNode iNode = GetVisualNode(compId);
VisualNode node = ((VisualNode)iNode);
if (null == node)
{
return(false);
}
type = node.VisualType;
double centerLine = 0;
double width = node.Width;
double height = node.Height;
if (nodePart == NodePart.None)
{
result.X = node.X;
result.Y = node.Y;
result.Width = node.Width;
result.Height = node.Height;
return(true);
}
if (nodePart == NodePart.North || nodePart == NodePart.South)
{
centerLine = node.CenterLine;
result.X = node.X;
result.Y = node.Y;
result.Width = centerLine;
result.Height = node.Height;
}
switch (node.VisualType)
{
case NodeType.Function:
centerLine = node.CenterLine;
if (nodePart == NodePart.Caption)
{
result = new Rect(new Point(node.X + centerLine, node.Y + 0), new Point(node.X + width, node.Y + height / 2));
return(true);
}
if (nodePart == NodePart.Text)
{
result = new Rect(new Point(node.X + centerLine, node.Y + height / 2), new Point(node.X + width, node.Y + height));
return(true);
}
if (nodePart == NodePart.ReplicationGuide)
{
FunctionNode fNode = node as FunctionNode;
result = new Rect(new Size(Configurations.ReplicationGuideWidth, Configurations.SlotStripeSize));
mousePt.X -= node.X;
mousePt.Y -= node.Y;
double deltaX = centerLine - mousePt.X;
int replicationIndex = (int)(deltaX / (Configurations.ReplicationGuideWidth + Configurations.TriangleHeight));
double slotCount = node.GetInputSlots().Count();
double slotHeight = (node.Height) / slotCount;
int slotIndex = (int)((mousePt.Y) / slotHeight);
result.Location = new Point(node.X + centerLine - fNode.GetMaxReplicationWidth(), node.Y + slotIndex * Configurations.SlotStripeSize + 1);
return(true);
}
//take inputSlots into consideration
break;
case NodeType.Driver:
centerLine = node.CenterLine;
if (nodePart == NodePart.Caption)
{
result = new Rect(new Point(node.X + 0, node.Y + 0), new Point(node.X + centerLine, node.Y + height));
return(true);
}
if (nodePart == NodePart.Text)
{
result = new Rect(new Point(node.X + centerLine, node.Y + 0), new Point(node.X + width, node.Y + height));
return(true);
}
break;
case NodeType.CodeBlock:
if (nodePart == NodePart.Text)
{
result = new Rect(new Point(node.X + 0, node.Y + 0), new Point(node.X + width, node.Y + height));
return(true);
}
break;
case NodeType.Identifier:
if (nodePart == NodePart.Caption)
{
result = new Rect(new Point(node.X + 0, node.Y + 0), new Point(node.X + width, node.Y + height));
return(true);
}
break;
case NodeType.Property:
if (nodePart == NodePart.Caption)
{
result = new Rect(new Point(node.X, node.Y + 0), new Point(node.X + width, node.Y + height / 2));
return(true);
}
else if (nodePart == NodePart.Text)
{
result = new Rect(new Point(node.X, node.Y + height / 2), new Point(node.X + width, node.Y + height));
return(true);
}
break;
default:
result = new Rect();
return(false);
}
return(false);
}
private void BeginDragSelectedNodes(double mouseX, double mouseY, VisualNode node)
{
if (node.Selected)
{
List<IVisualNode> nodeList = new List<IVisualNode>();
foreach (IVisualNode visualNode in nodeCollection.Values)
{
if (((VisualNode)visualNode).Selected)
{
nodeList.Add(visualNode);
DraggedNode draggedNode = new DraggedNode(visualNode);
draggedNode.DeltaX = mouseX - ((VisualNode)visualNode).X;
draggedNode.DeltaY = mouseY - ((VisualNode)visualNode).Y;
dragSet.Add(draggedNode);
edgeController.SelectEdges(visualNode);
//both node that the edge is connected to should be bring to front
foreach (VisualNode connectingNode in edgeController.GetNodesFromSelectedEdges())
RearrangeNodeAndBubbleVisual(connectingNode, true);
}
}
if (nodeList.Count > 0)
{
this.undoRedoRecorder.BeginGroup();
this.undoRedoRecorder.RecordNodeModificationForUndo(nodeList);
edgeController.BeginUpdateEdge();
this.undoRedoRecorder.EndGroup();
}
}
currentDragState = DragState.NodeRepositioning;
selectionBox.SetRelativePositionToMouse(mouseX, mouseY);
}
private void CreateNodeInternal(VisualNode node, double x, double y)
{
if (null == node)
throw new ArgumentNullException("node");
if (CoreComponent.Instance.StudioSettings.SuppressPreview)
node.SetNodeState(States.PreviewHidden);
node.X = x;
node.Y = y;
node.Compose(); // Just to compute the dimension.
DeltaNodes deltaNodes = new DeltaNodes();
deltaNodes.AppendToAddedNodes(node);
if (node.VisualType != NodeType.CodeBlock)
{
bool visualOnlyNode = (node.VisualType == NodeType.Condensed ||
(node.VisualType == NodeType.Render));
this.undoRedoRecorder.BeginGroup();
this.undoRedoRecorder.RecordRuntimeStatesForUndo(this.graphProperties.RuntimeStates);
this.undoRedoRecorder.RecordNodeCreationForUndo(deltaNodes.AddedNodes);
this.graphProperties.RuntimeStates.AddVariablesDefinedInNode(node, false);
if (false == visualOnlyNode)
{
List<IVisualNode> modifiedNodes = new List<IVisualNode>();
EstablishImplicitConnections(modifiedNodes);
deltaNodes.AppendToModifiedNodes(modifiedNodes);
}
this.undoRedoRecorder.EndGroup();
if (false == visualOnlyNode)
this.SynchronizeToLiveRunner(deltaNodes);
}
this.UpdateDirtyNodes();
node.PositionAtCenter(node.NodeId);
}
private bool IsInDragSet(VisualNode node, List<DraggedNode> dragSet)
{
foreach (DraggedNode draggedNode in dragSet)
{
if (draggedNode.node == node)
return true;
}
return false;
}
private bool HandleMouseDown(GraphCommand command)
{
MouseButton button = ((MouseButton)command.GetArgument(0));
uint compId = ((uint)command.GetArgument(1));
NodePart nodePart = ((NodePart)command.GetArgument(2));
int slotIndex = ((int)command.GetArgument(3));
ModifierKeys modifiers = ((ModifierKeys)command.GetArgument(4));
if (nodePart != NodePart.None)
{
if (IdGenerator.GetType(compId) != ComponentType.Node)
{
throw new InvalidOperationException("Component type mismatch!");
}
IVisualNode node = null;
nodeCollection.TryGetValue(compId, out node);
if (null == node)
{
throw new ArgumentException("Invalid argument!", "compId");
}
VisualNode visualNode = node as VisualNode;
switch (nodePart)
{
case NodePart.North:
case NodePart.South:
case NodePart.NorthEast:
case NodePart.NorthWest:
case NodePart.PreviewNorthEast:
case NodePart.Preview:
ClearSelectionInternal();
RearrangeNodeAndBubbleVisual(visualNode, true);
visualNode.Selected = true;
break;
case NodePart.Caption:
case NodePart.Text:
case NodePart.ReplicationGuide:
case NodePart.InputLabel:
if (visualNode.Selected)
{
if (modifiers.HasFlag(ModifierKeys.Control)) //remove the selected node and update the edge
{
visualNode.Selected = false;
}
}
else
{
if (!modifiers.HasFlag(ModifierKeys.Control) && !modifiers.HasFlag(ModifierKeys.Shift))
{
ClearSelectionInternal();
}
RearrangeNodeAndBubbleVisual(visualNode, true);
visualNode.Selected = true;
}
break;
case NodePart.InputSlot:
case NodePart.OutputSlot:
break;
}
if (null != visualNode)
{
visualNode.Compose(); // Redraw for selection change.
}
}
selectionBox.UpdateSelectionBox(GetSelectedNodes());
return(true);
}
private void TransformBubble(VisualNode node, TranslateTransform transform)
{
uint errorBubbleId = node.GetErrorBubbleId();
uint previewBubbleId = node.GetPreviewBubbleId();
if (errorBubbleId != uint.MaxValue)
{
DrawingVisual errorVisual = visualHost.GetDrawingVisualForBubble(errorBubbleId);
//RearrangeVisual(errorBubbleId, true);
errorVisual.Transform = transform;
}
if (previewBubbleId != uint.MaxValue)
{
DrawingVisual previewVisual = visualHost.GetDrawingVisualForBubble(previewBubbleId);
//RearrangeVisual(previewBubbleId, true);
previewVisual.Transform = transform;
}
}
private bool HandleEndDrag(GraphCommand command)
{
MouseButton button = ((MouseButton)command.GetArgument(0));
uint compId = ((uint)command.GetArgument(1));
NodePart nodePart = ((NodePart)command.GetArgument(2));
int slotIndex = ((int)command.GetArgument(3));
ModifierKeys modifiers = ((ModifierKeys)command.GetArgument(4));
double mouseX = ((double)command.GetArgument(5));
double mouseY = ((double)command.GetArgument(6));
switch (currentDragState)
{
case DragState.NodeRepositioning:
foreach (DraggedNode draggedNode in dragSet)
{
((VisualNode)draggedNode.node).X = mouseX - draggedNode.DeltaX;
((VisualNode)draggedNode.node).Y = mouseY - draggedNode.DeltaY;
}
// both node that the edge is connected to should be bring to back
//
foreach (VisualNode connectingNode in edgeController.GetNodesFromSelectedEdges())
{
if (!connectingNode.Selected)
{
RearrangeNodeAndBubbleVisual(connectingNode, false);
}
}
dragSet.Clear();
edgeController.ResetAllEdges();
break;
case DragState.CurveDrawing:
case DragState.EdgeReconnection:
edgeConnection = EdgeConnectionFlag.None;
VisualNode node = GetVisualNode(edgeController.GetConnectNodeId());
if (null != node)
{
node.PreviewSelected = node.Selected;
node.Compose(); // Optionally redraw the node.
}
node = GetVisualNode(edgeController.GetCurrentlySelectedNodeId());
if (null != node)
{
node.Selected = false;
node.Compose(); // reset highlighted node
}
node = GetVisualNode(compId);
List <IVisualNode> modifiedNodes = null;
edgeConnection = edgeController.AttemptConnectEdge(node, nodePart, slotIndex, out modifiedNodes);
DeltaNodes deltaNodes = new DeltaNodes();
deltaNodes.AppendToModifiedNodes(modifiedNodes.Distinct().ToList());
//reset highlighted node
foreach (IVisualNode visualNode in deltaNodes.ModifiedNodes)
{
((VisualNode)visualNode).Selected = false;
}
// Start tracking variables being undefined in this process.
{
RuntimeStates runtimeStates = graphProperties.RuntimeStates;
runtimeStates.BeginDefinitionMonitor();
undoRedoRecorder.BeginGroup();
undoRedoRecorder.RecordRuntimeStatesForUndo(runtimeStates);
undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
edgeController.CreateEdge();
modifiedNodes.Clear();
this.EstablishImplicitConnections(modifiedNodes);
undoRedoRecorder.EndGroup();
Dictionary <uint, List <string> > undefinedVariables = null;
runtimeStates.EndDefinitionMonitor(out undefinedVariables);
deltaNodes.AppendUndefinedVariables(undefinedVariables);
}
deltaNodes.AppendToModifiedNodes(modifiedNodes);
if (deltaNodes.ModifiedNodes.Count > 0) //modification have been done
{
SynchronizeToLiveRunner(deltaNodes);
}
else
{
undoRedoRecorder.PopRecordFromUndoStorage();
}
edgeController.ResetParameters();
edgeController.ResetAllEdges();
currentDragState = DragState.None;
edgeConnection = EdgeConnectionFlag.None;
break;
case DragState.RegionSelection:
if (visualHost != null)
{
visualHost.EndDragSelection();
}
break;
}
//currentDragState = DragState.None;
selectionBox.UpdateSelectionBox(GetSelectedNodes());
return(true);
}
private void TransferInformationFromMethodToProperty(VisualNode sourceNode, VisualNode destinationNode)
{
if (sourceNode == null)
throw new ArgumentNullException("sourceNode");
if (sourceNode == null)
throw new ArgumentNullException("destinationNode");
destinationNode.Text = sourceNode.Text;
Slot destinationInputSlot = this.GetSlot(destinationNode.GetInputSlot(0)) as Slot;
Slot sourceInputSlot = this.GetSlot(sourceNode.GetInputSlot(0)) as Slot;
if (sourceInputSlot.ConnectingSlots != null)
{
Slot outputSlot = this.GetSlot(sourceInputSlot.ConnectingSlots[0]) as Slot;
this.edgeController.CreateLinkingEdge(outputSlot, destinationInputSlot);
}
Slot destinationOutputSlot = this.GetSlot(destinationNode.GetOutputSlot(0)) as Slot;
Slot sourceOutputSlot = this.GetSlot(sourceNode.GetOutputSlot(0)) as Slot;
if (sourceOutputSlot.ConnectingSlots != null)
{
foreach (uint slotId in sourceOutputSlot.ConnectingSlots)
{
Slot inputSlot = this.GetSlot(slotId) as Slot;
this.edgeController.CreateLinkingEdge(destinationOutputSlot, inputSlot);
}
}
List<string> defined = sourceNode.GetDefinedVariables(false);
graphProperties.RuntimeStates.TransferVariableDefinitionMapping(
defined, sourceNode.NodeId, destinationNode.NodeId);
}
private bool HandleEndNodeEdit(GraphCommand command)
{
uint nodeId = (uint)command.GetArgument(0);
string text = command.GetArgument(1) as string;
bool commit = (bool)command.GetArgument(2);
VisualNode node = this.GetVisualNode(nodeId);
bool setToPreviousValue = false;
bool setToDefaultValue = false;
bool recordAsCreation = false;
bool recordAndDelete = false;
bool validate = false;
bool delete = false;
text = node.PreprocessInputString(text);
bool committingEmptyContent = text == string.Empty;
bool committingSameContent = text == this.previousText;
bool startedOffDefaultValueDriver = this.previousText == Configurations.DriverInitialTextValue;
bool committingEmptyCodeBlock = text == string.Empty || text == Configurations.CodeBlockInitialMessage;
bool startedOffEmptyCodeBlock = this.previousText == string.Empty || this.previousText == Configurations.CodeBlockInitialMessage;
//Flow logic
if (node.VisualType == NodeType.CodeBlock)
{
if (commit)
{
if (committingEmptyCodeBlock)
{
if (startedOffEmptyCodeBlock)
{
delete = true;
}
else
{
recordAndDelete = true;
}
}
else //Not Empty
{
if (!committingSameContent)
{
validate = true;
}
if (startedOffEmptyCodeBlock)
{
recordAsCreation = true;
}
}
}
else //Not committing
{
if (startedOffEmptyCodeBlock)
{
delete = true;
}
}
}
else if (node.VisualType == NodeType.Driver)
{
if (commit)
{
if (committingEmptyContent)
{
if (node.IsEditingText)
{
setToDefaultValue = true;
}
else if (node.IsEditingCaption)
{
setToPreviousValue = true;
}
}
else //Not Empty
{
if (!committingSameContent)
{
validate = true;
}
}
}
}
else //Other nodes
{
if (commit)
{
if (committingEmptyContent)
{
setToPreviousValue = true;
}
else //Not empty
{
if (!committingSameContent)
{
validate = true;
}
}
}
}
//Execution
node.Edit(this.previousText, false);
if (delete)
{
if (null != visualHost)
{
this.visualHost.RemoveDrawingVisual(node.NodeId);
this.visualHost.RemoveDrawingVisual(node.GetErrorBubbleId());
this.visualHost.RemoveDrawingVisual(node.GetPreviewBubbleId());
this.visualHost.RemoveExtendedBubble(node.GetPreviewBubbleId());
}
uint[] outputSlots = node.GetOutputSlots();
uint[] inputSlots = node.GetInputSlots();
if (inputSlots != null)
{
foreach (uint inputSlot in inputSlots)
{
this.slotCollection.Remove(inputSlot);
}
}
if (outputSlots != null)
{
foreach (uint outputSlot in outputSlots)
{
this.slotCollection.Remove(outputSlot);
}
}
this.nodeCollection.Remove(node.NodeId);
this.bubbleCollection.Remove(node.GetErrorBubbleId());
this.bubbleCollection.Remove(node.GetPreviewBubbleId());
}
if (recordAndDelete)
{
DeltaNodes deltaNodes = new DeltaNodes();
deltaNodes.AppendToRemovedNodes(node);
deltaNodes.AppendToModifiedNodes(FindAssociatedNodesFromNodes(deltaNodes.RemovedNodes));
this.undoRedoRecorder.BeginGroup();
this.undoRedoRecorder.RecordRuntimeStatesForUndo(this.graphProperties.RuntimeStates);
this.undoRedoRecorder.RecordNodeDeletionForUndo(deltaNodes.RemovedNodes);
this.undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
this.DeleteNodes(deltaNodes.RemovedNodes);
this.undoRedoRecorder.EndGroup();
this.ValidateDefinedAndReferencedVariables();
this.UpdateSlotsVisiblity();
this.SynchronizeToLiveRunner(deltaNodes);
}
if (setToDefaultValue)
{
if (!startedOffDefaultValueDriver)
{
DeltaNodes deltaNodes = new DeltaNodes();
deltaNodes.AppendToModifiedNodes(node);
this.undoRedoRecorder.BeginGroup();
this.undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
this.undoRedoRecorder.EndGroup();
node.Edit(Configurations.DriverInitialTextValue, false);
this.SynchronizeToLiveRunner(deltaNodes);
}
string warningMessage = "Field cannot be empty. Value will be set to 0.";
node.SetErrorValue((object)warningMessage, ErrorType.Warning);
}
if (setToPreviousValue)
{
string warningMessage = "Field cannot be empty. Value will be reverted to previous state.";
node.SetErrorValue((object)warningMessage, ErrorType.Warning);
}
if (validate)
{
DeltaNodes deltaNodes = new DeltaNodes();
List <IVisualNode> addedNodes = new List <IVisualNode>();
List <IVisualNode> modifiedNodes = new List <IVisualNode>();
addedNodes.Add(node); // deltaNodes.AppendToAddedNodes(node);
// Start monitoring if we are going to undefine any variables.
this.graphProperties.RuntimeStates.BeginDefinitionMonitor();
this.undoRedoRecorder.BeginGroup();
this.undoRedoRecorder.RecordRuntimeStatesForUndo(this.graphProperties.RuntimeStates);
if (recordAsCreation)
{
this.undoRedoRecorder.RecordNodeCreationForUndo(addedNodes);
}
else //record edited node as modification
{
deltaNodes.AppendToModifiedNodes(node);
deltaNodes.AppendToModifiedNodes(FindAssociatedNodesFromNodes(addedNodes));
this.undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
}
// These methods (especially the first two and last two) must be
// called in this particular order (due to their dependencies).
//
// GC.ValidateNodesSyntax
// RS.UpdateVariableDefinitionMap
// GC.ValidateDefinedAndReferencedVariables
// GC.UpdateSlotsVisiblity
// GC.EstablishImplicitConnections
//
node.SetErrorValue(null, ErrorType.None);
node.Edit(text, false);
this.ValidateNodesSyntax(addedNodes);
this.graphProperties.RuntimeStates.UpdateVariablesDefinedInNode(node, false);
this.ValidateDefinedAndReferencedVariables();
this.UpdateSlotsVisiblity();
this.EstablishImplicitConnections(modifiedNodes);
this.edgeController.DeleteUnnecessaryEdges();
this.undoRedoRecorder.EndGroup();
// Now all the modifications are over, see what we have undefined.
Dictionary <uint, List <string> > undefinedVariables = null;
this.graphProperties.RuntimeStates.EndDefinitionMonitor(out undefinedVariables);
deltaNodes.AppendUndefinedVariables(undefinedVariables);
if (recordAsCreation)
{
deltaNodes.AppendToAddedNodes(addedNodes);
}
deltaNodes.AppendToModifiedNodes(modifiedNodes);
this.SynchronizeToLiveRunner(deltaNodes);
}
this.UpdateDirtyNodes();
this.edgeController.UpdateEdgeConnectTo(node);
node.DisableEdit();
if (validate && visualHost != null)
{
visualHost.ScrollToVisual(visualHost.GetDrawingVisualForNode(node.NodeId));
}
return(true);
}
internal void AddVariablesDefinedInNode(VisualNode node, bool isPriority)
{
List<string> variables = node.GetDefinedVariables(false);
if (variables == null || variables.Count <= 0)
return;
foreach (string variable in variables)
this.AddDefinition(variable, node.NodeId, isPriority);
}
private void GetFunctionNodeMenuItems()
{
ObservableCollection <LibraryItem> libraryItems = new ObservableCollection <LibraryItem>();
libraryItemCollection = new Dictionary <int, LibraryItem>();
VisualNode node = graphController.GetVisualNode(this.nodeId);
FunctionNode fNode = (FunctionNode)node;
Dictionary <int, string> functionNodeItems = new Dictionary <int, string>();
if (node.GetAssembly() == null || node.ReturnType == null)
{
return;
}
string[] assemblies = (node.GetAssembly()).Split(',');
string[] returnTypes = (node.ReturnType.Split(','));
switch (nodePart)
{
case NodePart.NorthEast:
//case NodePart.South:
this.GetMethodsAndProperties(assemblies, returnTypes, libraryItems);
break;
case NodePart.North:
if (fNode.MemberType == LibraryItem.MemberType.Constructor)
{
libraryItems = CoreComponent.Instance.GetConstructors(fNode.Assembly, fNode.QualifiedName);
}
else if (fNode.MemberType == LibraryItem.MemberType.InstanceMethod)
{
string argumentTypes = fNode.ArgumentTypes;
string[] tempArray = argumentTypes.Split(',');
string parentReturnType = tempArray[0];
if (parentReturnType == "this")
{
uint slotId = node.GetInputSlot(0);
ISlot slot = graphController.GetSlot(slotId);
uint[] connectingSlots = slot.ConnectingSlots;
if (connectingSlots != null)
{
ISlot parentSlot = graphController.GetSlot(connectingSlots[0]);
VisualNode visualNode = graphController.GetVisualNode(parentSlot.Owners[0]);
parentReturnType = visualNode.ReturnType;
string[] tempParent = { parentReturnType };
this.GetMethodsAndProperties(assemblies, tempParent, libraryItems);
//libraryItems = CoreComponent.Instance.GetMethodsAndProperties(fNode.Assembly, parentReturnType);
}
}
else
{
libraryItems = CoreComponent.Instance.GetMethodsAndProperties(fNode.Assembly, parentReturnType);
}
}
break;
case NodePart.NorthWest:
Dictionary <int, string> temp = new Dictionary <int, string>();
this.GetNodeOptions(this.nodeId, out temp);
functionNodeItems = temp;
break;
default:
break;
}
this.PopulateItems(libraryItems);
return;
}
internal void RemoveVariablesDefinedInNode(VisualNode node)
{
List<string> variables = node.GetDefinedVariables(false);
if (variables == null || variables.Count <= 0)
return;
foreach (string variable in variables)
this.RemoveDefinition(variable, node.NodeId);
}
internal List<IVisualEdge> FindEdgeConnectTo(VisualNode node)
{
List<IVisualEdge> edgeList = new List<IVisualEdge>();
uint[] inputs = node.GetInputSlots();
uint[] outputs = node.GetOutputSlots();
if (inputs != null)
{
foreach (uint slotId in inputs)
{
foreach (VisualEdge visualEdge in edgeCollection.Values)
if (visualEdge.EndSlotId == slotId)
edgeList.Add(visualEdge);
}
}
if (outputs != null)
{
foreach (uint slotId in outputs)
{
foreach (VisualEdge visualEdge in edgeCollection.Values)
if (visualEdge.StartSlotId == slotId)
edgeList.Add(visualEdge);
}
}
return edgeList;
}
private void EstablishExplicitOutputConnection(VisualNode startNode, Connection connection, List<IVisualNode> modifiedNodes)
{
VisualNode endNode = nodeCollection[connection.OtherNode] as VisualNode;
List<uint> startSlotIds = (startNode as VisualNode).GetSlotIdsByName(SlotType.Output, connection.LocalName);
uint startSlotId = startSlotIds.Last();
uint endSlotId = endNode.GetInputSlot(connection.OtherIndex);
Slot outputSlot = GetSlot(startSlotId) as Slot;
Slot inputSlot = GetSlot(endSlotId) as Slot;
edgeController.CreateLinkingEdge(outputSlot, inputSlot);
(startNode as VisualNode).HandleNewConnection(startSlotId);
endNode.HandleNewConnection(endSlotId);
modifiedNodes.Add(startNode);
modifiedNodes.Add(endNode);
}
