internal bool RunCommands(string inputCommands)
{
inputCommands = inputCommands.Replace("\r\n", "\n");
char[] delimiter = new char[] { '\n' };
string[] commands = inputCommands.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
if (null == commands || (commands.Length == 0))
{
return(false);
}
foreach (string command in commands)
{
if (null == command)
{
continue;
}
string trimmed = command.Trim();
if (string.IsNullOrEmpty(trimmed))
{
continue;
}
GraphCommand graphCommand = GraphCommand.FromString(trimmed);
if (!RerouteToHandler(graphCommand))
{
return(false);
}
}
return(true);
}
private bool HandleUndoOperation(GraphCommand command)
{
DeltaNodes deltaNodes = new DeltaNodes();
// Start tracking variables being undefined in this process.
{
RuntimeStates runtimeStates = this.GetRuntimeStates();
runtimeStates.BeginDefinitionMonitor();
this.undoRedoRecorder.Undo(deltaNodes);
Dictionary <uint, List <string> > undefinedVariables = null;
runtimeStates.EndDefinitionMonitor(out undefinedVariables);
deltaNodes.AppendUndefinedVariables(undefinedVariables);
}
this.ValidateNodesSyntax(this.nodeCollection.Values.ToList <IVisualNode>());
this.ValidateDefinedAndReferencedVariables();
if (false == deltaNodes.IsEmpty)
{
this.SynchronizeToLiveRunner(deltaNodes);
}
this.UpdateDirtyNodes();
this.edgeController.UpdateDirtyEdges(deltaNodes.ModifiedNodes);
selectionBox.UpdateSelectionBox(GetSelectedNodes());
return(true);
}
public bool DoTogglePreview(uint bubbleId)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.TogglePreview);
command.AppendArgument(bubbleId);
return(RerouteToHandler(command));
}
private bool HandleSelectComponent(GraphCommand command)
{
uint compId = (uint)command.GetArgument(0);
ModifierKeys modifiers = ((ModifierKeys)command.GetArgument(1));
IVisualNode selectedNode = null;
nodeCollection.TryGetValue(compId, out selectedNode);
if (selectedNode != null)
{
VisualNode node = (VisualNode)selectedNode;
if (modifiers.HasFlag(ModifierKeys.Control))//toggle
{
node.Selected = !node.Selected;
}
else
{
node.Selected = true;
}
}
else
{
edgeController.SelectComponent(compId, modifiers);
}
this.selectionBox.UpdateSelectionBox(GetSelectedNodes());
return(true);
}
public bool DoSaveGraph(string filePath)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.SaveGraph);
command.AppendArgument(filePath);
return(RerouteToHandler(command));
}
public bool DoImportScript(string scriptPath)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.ImportScript);
command.AppendArgument(scriptPath);
return(RerouteToHandler(command));
}
private bool HandleSetReplicationGuideText(GraphCommand command)
{
uint nodeId = (uint)command.GetArgument(0);
int replicationIndex = (int)command.GetArgument(1);
string text = ((string)command.GetArgument(2));
VisualNode node = GetVisualNode(nodeId);
if (node.VisualType != NodeType.Function)
{
throw new InvalidOperationException("Node must be FunctionNode");
}
DeltaNodes deltaNodes = new DeltaNodes();
IVisualNode iNode = this.GetVisualNode(nodeId);
deltaNodes.AppendToModifiedNodes(iNode);
FunctionNode fNode = node as FunctionNode;
undoRedoRecorder.BeginGroup();
undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
undoRedoRecorder.EndGroup();
fNode.SetReplicationText(replicationIndex, text);
//if(!fNode.SetReplicationText(replicationIndex,text))
// undoRedoRecorder.PopRecordFromUndoStorage();
node.DisableEdit();
node.Dirty = true;
node.Compose();
this.SynchronizeToLiveRunner(deltaNodes);
return(true);
}
private bool HandleCreateCodeBlockNode(GraphCommand command)
{
double mouseX = ((double)command.GetArgument(0));
double mouseY = ((double)command.GetArgument(1));
string content = command.GetArgument(2) as string;
CodeBlockNode node = new CodeBlockNode(this, content);
object parameter = null;
int intResult = 0;
bool boolResult = false;
double dblResult = 0;
if (Int32.TryParse(content, out intResult))
{
parameter = intResult;
}
else if (Double.TryParse(content, out dblResult))
{
parameter = dblResult;
}
else if (Boolean.TryParse(content, out boolResult))
{
parameter = boolResult;
}
else
{
parameter = content; // String type.
}
this.CreateNodeInternal(node, mouseX, mouseY);
return(true);
}
public bool DoCreateSubRadialMenu(int selectedItemId)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.CreateSubRadialMenu);
command.AppendArgument(selectedItemId);
return(RerouteToHandler(command));
}
private bool HandleImportScript(GraphCommand command)
{
string scriptPath = (string)command.GetArgument(0);
if (string.IsNullOrEmpty(scriptPath))
{
return(false);
}
// check if the file is already imported
if (this.GetImportedScripts().Exists((string file) => scriptPath.Equals(file, StringComparison.InvariantCultureIgnoreCase)))
{
CoreComponent.Instance.AddFeedbackMessage(ResourceNames.Error, UiStrings.DuplicateFailure.Replace("fileName", System.IO.Path.GetFileName(scriptPath)));
return(false);
}
if (CoreComponent.Instance.ImportAssembly(scriptPath, this.FilePath, false))
{
List <string> scripts = this.GetImportedScripts();
if (!scripts.Exists((string file) => scriptPath.Equals(file, StringComparison.InvariantCultureIgnoreCase)))
{
scripts.Add(scriptPath);
}
}
return(true);
}
public bool DoRemoveReplicationGuide(uint nodeId)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.RemoveReplicationGuide);
command.AppendArgument(nodeId);
return(RerouteToHandler(command));
}
public bool DoEndHighFrequencyUpdate(string text)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.EndHighFrequencyUpdate);
command.AppendArgument(text);
return(RerouteToHandler(command));
}
private bool HandleBeginHighFrequencyUpdate(GraphCommand command)
{
uint nodeId = (uint)command.GetArgument(0);
NodePart nodePart = ((NodePart)command.GetArgument(1));
nodeSelectedForHighFrequencyUpdate = GetVisualNode(nodeId);
if (null == nodeSelectedForHighFrequencyUpdate)
{
return(false);
}
// @TODO(Ben): The caller would have to specify NodePart in
// the near future, but for now we are making some assumption.
//
switch (nodeSelectedForHighFrequencyUpdate.VisualType)
{
case NodeType.Driver:
nodePart = NodePart.Text;
break;
default:
throw new InvalidOperationException("Not available for other node type (097D3A07D806)");
}
nodeSelectedForHighFrequencyUpdate.EnableEdit(nodePart, -1);
return(true);
}
private bool HandleCreateSubRadialMenu(GraphCommand command)
{
int selectedItemId = (int)command.GetArgument(0);
this.itemsProvider.PopulateOverloads(selectedItemId);
return(true);
}
public bool DoCreateRadialMenu(NodePart nodePart, uint nodeId)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.CreateRadialMenu);
command.AppendArgument(nodePart);
command.AppendArgument(nodeId);
return(RerouteToHandler(command));
}
public bool DoEditReplicationGuide(uint compId, int replicationIndex)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.EditReplicationGuide);
command.AppendArgument(compId);
command.AppendArgument(replicationIndex);
return(RerouteToHandler(command));
}
public bool DoSelectComponent(uint compId, ModifierKeys modifiers)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.SelectComponent);
command.AppendArgument(compId);
command.AppendArgument(modifiers);
return(RerouteToHandler(command));
}
public bool DoBeginHighFrequencyUpdate(uint nodeId, NodePart nodePart)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.BeginHighFrequencyUpdate);
command.AppendArgument(nodeId);
command.AppendArgument(nodePart);
return(RerouteToHandler(command));
}
public bool DoBeginNodeEdit(uint compId, NodePart nodePart)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.BeginNodeEdit);
command.AppendArgument(compId);
command.AppendArgument(nodePart);
return(RerouteToHandler(command));
}
public bool DoCreateDriverNode(double mouseX, double mouseY)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.CreateDriverNode);
command.AppendArgument(mouseX);
command.AppendArgument(mouseY);
return(RerouteToHandler(command));
}
private bool HandleCreateRadialMenu(GraphCommand command)
{
NodePart part = ((NodePart)command.GetArgument(0));
uint nodeId = (uint)command.GetArgument(1);
this.itemsProvider = new MenuItemsProvider(this, part, nodeId);
return(true);
}
private bool HandleEndHighFrequencyUpdate(GraphCommand command)
{
string text = command.GetArgument(0) as string;
UpdateNodeTextHighFrequency(text);
nodeSelectedForHighFrequencyUpdate = null;
return(true);
}
public bool DoCreateCodeBlockNode(double mouseX, double mouseY, string content)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.CreateCodeBlockNode);
command.AppendArgument(mouseX);
command.AppendArgument(mouseY);
command.AppendArgument(content);
return(RerouteToHandler(command));
}
public bool DoEndNodeEdit(uint compId, string text, bool updateFlag)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.EndNodeEdit);
command.AppendArgument(compId);
command.AppendArgument(text);
command.AppendArgument(updateFlag);
return(RerouteToHandler(command));
}
public bool DoSetReplicationGuideText(uint nodeId, int replicationIndex, string text)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.SetReplicationGuide);
command.AppendArgument(nodeId);
command.AppendArgument(replicationIndex);
command.AppendArgument(text);
return(RerouteToHandler(command));
}
private bool HandleEditReplicationGuide(GraphCommand command)
{
uint nodeId = (uint)command.GetArgument(0);
int replicationIndex = (int)command.GetArgument(1);
VisualNode node = this.GetVisualNode(nodeId);
node.EnableEdit(NodePart.ReplicationGuide, replicationIndex);
return(true);
}
public void TestToStringForEnum()
{
GraphCommand command = new GraphCommand(GraphCommand.Name.UndoOperation);
command.AppendArgument(NodeType.Function);
command.AppendArgument("Math.Sin");
command.AppendArgument(12.34);
command.AppendArgument(56.78);
Assert.AreEqual("UndoOperation|e:DesignScriptStudio.Graph.Core.NodeType,Function|s:Math.Sin|d:12.34|d:56.78", command.ToString());
}
private bool HandleCreateDriverNode(GraphCommand command)
{
double mouseX = ((double)command.GetArgument(0));
double mouseY = ((double)command.GetArgument(1));
DriverNode node = new DriverNode(this, Configurations.DriverInitialTextValue);
this.CreateNodeInternal(node, mouseX, mouseY);
return(true);
}
private bool HandleCreateRenderNode(GraphCommand command)
{
double mouseX = ((double)command.GetArgument(0));
double mouseY = ((double)command.GetArgument(1));
RenderNode node = new RenderNode(this, 0);
this.CreateNodeInternal(node, mouseX, mouseY);
return(true);
}
private bool HandleSaveGraph(GraphCommand command)
{
string filePath = command.GetArgument(0) as string;
this.filePath = filePath;
this.UpdateImportedLibrary();
this.SaveFileInternal(filePath);
this.FireFilePathSavedNotification();
return(true);
}
public bool DoSelectMenuItem(int menuItemId, double x, double y, uint nodeId, NodePart nodePart)
{
GraphCommand command = new GraphCommand(GraphCommand.Name.SelectMenuItem);
command.AppendArgument(menuItemId);
command.AppendArgument(x);
command.AppendArgument(y);
command.AppendArgument(nodeId);
command.AppendArgument(nodePart);
return(RerouteToHandler(command));
}
public void TestToStringForUnsigned()
{
GraphCommand command = new GraphCommand(GraphCommand.Name.UndoOperation);
command.AppendArgument("Math.Sin");
command.AppendArgument(12.34);
command.AppendArgument((uint)5678);
Assert.AreEqual("UndoOperation|s:Math.Sin|d:12.34|u:0x0000162e", command.ToString());
}
public void TestToStringWithLineBreak()
{
GraphCommand command = new GraphCommand(GraphCommand.Name.EndNodeEdit);
command.AppendArgument((uint)0x10000001);
command.AppendArgument("a=3;\nb=4;");
command.AppendArgument(true);
Assert.AreEqual("EndNodeEdit|u:0x10000001|s:a=3;\\nb=4;|b:True", command.ToString());
}
public void TestToStringWithArguments()
{
GraphCommand command = new GraphCommand(GraphCommand.Name.UndoOperation);
command.AppendArgument(1234);
command.AppendArgument(56.78);
command.AppendArgument(true);
command.AppendArgument("DesignScript Rocks!");
Assert.AreEqual("UndoOperation|i:1234|d:56.78|b:True|s:DesignScript Rocks!", command.ToString());
}
public void TestToStringNoArgument()
{
GraphCommand command = new GraphCommand(GraphCommand.Name.UndoOperation);
Assert.AreEqual("UndoOperation", command.ToString());
}
private void PreProcessCommand(GraphCommand.Name commandName)
{
if (commandName == GraphCommand.Name.SaveGraph)
this.IsModified = true;
undoStoragePreProcessCommandPosition = undoRedoRecorder.GetUndoPosition();
//case GraphCommand.Name.SaveGraph:
// this.IsModified = false;
// break;
//case GraphCommand.Name.UndoOperation:
//case GraphCommand.Name.RedoOperation:
// // Undo/redo does nothing for modified state.
// break;
//default:
// this.IsModified = true;
// break;
}
internal static GraphCommand FromString(string content)
{
if (String.IsNullOrEmpty(content))
throw new ArgumentException("Invalid argument", "content");
content = content.Trim();
if (String.IsNullOrEmpty(content))
throw new ArgumentException("Invalid argument", "content");
char[] delimiter = new char[] { textDelimiter };
string[] inputs = content.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
if (null == inputs || (inputs.Length <= 0))
return null;
Type enumType = typeof(GraphCommand.Name);
object commandName = Enum.Parse(enumType, inputs[0]);
GraphCommand command = new GraphCommand((Name)commandName);
int inputIndex = 0;
foreach (string input in inputs)
{
// Skip past the command name.
if (inputIndex++ < 1)
continue;
if (String.IsNullOrEmpty(input))
throw new ArgumentException("Invalid argument", "content");
if ((input.Length < 2) || (input[1] != ':'))
throw new ArgumentException("Invalid argument", "content");
int intValue = 0;
bool boolValue = false;
double doubleValue = 0.0;
string value = input.Substring(2); // Skip past the "x:" portion.
switch (input[0])
{
case 'b':
if (!Boolean.TryParse(value, out boolValue))
throw new InvalidCastException("Invalid 'bool' value");
command.AppendArgument(boolValue);
break;
case 'd':
if (!Double.TryParse(value, out doubleValue))
throw new InvalidCastException("Invalid 'double' value");
command.AppendArgument(doubleValue);
break;
case 'e':
int commaIndex = value.IndexOf(',');
if (-1 == commaIndex)
throw new ArgumentException("Invalid argument", "content");
string fullTypeName = value.Substring(0, commaIndex);
string enumValue = value.Substring(commaIndex + 1); // Skip ','.
System.Type type = GraphCommand.GetEnumType(fullTypeName);
command.AppendArgument(Enum.Parse(type, enumValue));
break;
case 'i':
if (!Int32.TryParse(value, out intValue))
throw new InvalidCastException("Invalid 'int' value");
command.AppendArgument(intValue);
break;
case 's':
string transformed = value.Replace("\\n", "\n");
command.AppendArgument(transformed);
break;
case 'u':
if (value.StartsWith("0x") || value.StartsWith("0X"))
value = value.Substring(2);
uint unsignedValue = UInt32.Parse(value, NumberStyles.HexNumber);
command.AppendArgument(unsignedValue);
break;
}
}
return command;
}
private void PostProcessCommand(GraphCommand.Name commandName)
{
// The auto-saving timer expires in a given interval, and then it
// performs auto-saving for recovery later. Once saved, the timer
// is stopped, until user performs an action that alters the graph
// content (which is through graph commands channeling through the
// "RerouteToHandler" method). When the graph is modified, the
// timer then restarts here and wait for the interval to expire.
//
if (null != autoSaveTimer && (false == autoSaveTimer.IsEnabled))
{
autoSaveTimer.Stop(); // Just to be 100% sure.
autoSaveTimer.Start(); // Restart timer.
}
long undoStoragePosition = undoRedoRecorder.GetUndoPosition();
switch (commandName)
{
case GraphCommand.Name.UndoOperation:
case GraphCommand.Name.RedoOperation:
break;
case GraphCommand.Name.SaveGraph:
undoStorageSavedPosition = undoStoragePosition;
break;
default:
// for the case of action -> save -> undo ->action
// then the saved state will never be recovered from undoStorage
//
if (undoStoragePreProcessCommandPosition > undoStoragePosition // the command actually does some actions
&& undoStorageSavedPosition >= undoStoragePosition) // which makes the saved state unreachable
undoStorageSavedPosition = 0;
break;
}
if (undoStorageSavedPosition == undoStoragePosition)
this.IsModified = false;
else
this.IsModified = true;
undoStoragePreProcessCommandPosition = -1;
}
private bool RerouteToHandler(GraphCommand command)
{
try
{
if (null != visualHost && (false != visualHost.IsInRecordingMode))
recordedCommands.Add(command.ToString());
bool callResult = false;
currentCommand = command.CommandName;
this.PreProcessCommand(command.CommandName);
switch (command.CommandName)
{
case GraphCommand.Name.CreateCodeBlockNode:
callResult = HandleCreateCodeBlockNode(command);
break;
case GraphCommand.Name.CreateDriverNode:
callResult = HandleCreateDriverNode(command);
break;
case GraphCommand.Name.CreateFunctionNode:
callResult = HandleCreateFunctionNode(command);
break;
case GraphCommand.Name.CreateIdentifierNode:
callResult = HandleCreateIdentifierNode(command);
break;
case GraphCommand.Name.CreateRenderNode:
callResult = HandleCreateRenderNode(command);
break;
case GraphCommand.Name.CreatePropertyNode:
callResult = HandleCreatePropertyNode(command);
break;
case GraphCommand.Name.SaveGraph:
callResult = HandleSaveGraph(command);
break;
case GraphCommand.Name.MouseDown:
callResult = HandleMouseDown(command);
break;
case GraphCommand.Name.MouseUp:
callResult = HandleMouseUp(command);
break;
case GraphCommand.Name.BeginDrag:
callResult = HandleBeginDrag(command);
break;
case GraphCommand.Name.EndDrag:
callResult = HandleEndDrag(command);
break;
case GraphCommand.Name.BeginNodeEdit:
callResult = HandleBeginNodeEdit(command);
break;
case GraphCommand.Name.EndNodeEdit:
callResult = HandleEndNodeEdit(command);
break;
case GraphCommand.Name.BeginHighFrequencyUpdate:
callResult = HandleBeginHighFrequencyUpdate(command);
break;
case GraphCommand.Name.EndHighFrequencyUpdate:
callResult = HandleEndHighFrequencyUpdate(command);
break;
case GraphCommand.Name.DeleteComponents:
callResult = HandleDeleteComponents(command);
break;
case GraphCommand.Name.SelectComponent:
callResult = HandleSelectComponent(command);
break;
case GraphCommand.Name.ClearSelection:
callResult = HandleClearSelection(command);
break;
case GraphCommand.Name.UndoOperation:
callResult = HandleUndoOperation(command);
break;
case GraphCommand.Name.RedoOperation:
callResult = HandleRedoOperation(command);
break;
case GraphCommand.Name.EditReplicationGuide:
callResult = HandleEditReplicationGuide(command);
break;
case GraphCommand.Name.SetReplicationGuide:
callResult = HandleSetReplicationGuideText(command);
break;
case GraphCommand.Name.SelectMenuItem:
callResult = HandleSelectedMenuItem(command);
break;
case GraphCommand.Name.CreateRadialMenu:
callResult = HandleCreateRadialMenu(command);
break;
case GraphCommand.Name.CreateSubRadialMenu:
callResult = HandleCreateSubRadialMenu(command);
break;
case GraphCommand.Name.ImportScript:
callResult = HandleImportScript(command);
break;
case GraphCommand.Name.ConvertSelectionToCode:
callResult = HandleConvertSelectionToCode();
break;
case GraphCommand.Name.TogglePreview:
callResult = HandleTogglePreview(command);
break;
}
this.PostProcessCommand(this.currentCommand);
currentCommand = GraphCommand.Name.None;
return callResult;
}
catch (Exception exception)
{
if (null != visualHost && (false != visualHost.IsInRecordingMode))
{
string filePath = this.DumpUiStatesToExternalFile(exception);
if (System.IO.File.Exists(filePath))
System.Diagnostics.Process.Start(filePath);
string xmlFilePath = this.DumpVmStatesToExternalFile();
if (System.IO.File.Exists(xmlFilePath))
System.Diagnostics.Process.Start(xmlFilePath);
}
throw exception; // Rethrow to external handler.
}
throw new InvalidOperationException("Unhandled command in 'RerouteToHandler'");
}